Statically casting an integer to pointer type

Question

I just can't find out how this simple example can be compiled in C++ :

class C
{
  public:
    static const void* noop = static_cast<const void*> (0x1);
};

Because of the static storage constraint I want, the only cast possible here would be static_cast but it is incompatible with this int-to-ptr cast.

error: invalid static_cast from type ‘int’ to type ‘const void*’

How can an integer value be statically casted to a pointer type?

You're getting a descriptive error with your `static_cast`, I bet. Can you share it? — Drew Dormann, Jun 24 '14 at 23:14
how about [this](http://coliru.stacked-crooked.com/a/df7f9e0b0edb48dc) — Bryan Chen, Jun 24 '14 at 23:20
This code doesn't work for me even if I try to assign NULL instead of 0x1. It gives `error: non-const static data member must be initialized out of line` (clang++) — cobbal, Jun 24 '14 at 23:20
As I state in my answer it seems like using `intptr_t` leads to a better solution. — Shafik Yaghmour, Jun 30 '14 at 02:26

101010 · Accepted Answer · 2014-06-25T11:44:43.280

4

The problem here is that although you are declaring a const void* the const qualifier doesn't apply to the pointer but to the address that this pointer points to.

This means that noop is not a static const member variable and as all non const static member variables needs to be defined and initialized in a single translation unit outside class's definition like the example below:

class C {
  public:
    static const void *noop;
};

const void* C::noop = (const void*) 0x1;

Live Demo

The following solution:

class C {
public:
  static constexpr const void* noop = reinterpret_cast<const void*>(0x1);
};

Although, it compiles and works fine in GCC isn't valid C++ (e.g., it doesn't compile with either clang or VC++2013) because according to the standard § 5.19/2 Constant Expressions [expr.const] the result of a reinterpret_cast can't be a constant expression.

edited Jun 25 '14 at 11:44

answered Jun 25 '14 at 01:05

101010

41,839
11
94
168

Also, why did you make the variable non-const? – Ben Voigt Jun 25 '14 at 01:27
@BenVoigt in the example provided by the OP is non-const. – 101010 Jun 25 '14 at 02:25
@40two: Sorry, I spent too much time looking at the `constexpr` attempts. – Ben Voigt Jun 25 '14 at 15:00

score 3 · Answer 2 · edited May 23 '17 at 12:00

3

reinterpret_cast is what you are looking for (raw interpretation of the bytes of an int to a const void* pointer)

Also, you need constexpr for in-class initialization of static data member :

class C
{
  public:
    static constexpr const void* noop = reinterpret_cast<const void*>(0x1);
};

static_cast doesn't work since there is no combination of user-defined or implicit conversions that would transform an int to a const void*.

EDIT:

This solution is not standard C++ (reinterpret_cast is not allowed in constant expressions), 40two solution's is correct.

edited May 23 '17 at 12:00

Community

1
1

answered Jun 24 '14 at 23:21

quantdev

23,517
5
55
88

1

@DrewDormann: Nope: http://coliru.stacked-crooked.com/a/685b3b1ee008f14c. It needs both. – Mooing Duck Jun 24 '14 at 23:26
I missed the `constexpr` ! C++11 gives me headache... Thank you ! – Julio Guerra Jun 24 '14 at 23:30
@quantdev No, it's a pointer to a `const void` but the pointer is non-const. – David G Jun 24 '14 at 23:44
This is wrong the result of `reinterpret_cast` is never a constant expression. – 101010 Jun 25 '14 at 00:01

score 1 · Answer 3 · answered Jun 25 '14 at 01:26

40two has fixed the compile error, but also made the member non-const, which is undesirable because it hinders optimization and opens to door to accidental mutation.

Best:

class C {
  public:
    static const void* const noop;
};

const void* const C::noop = reinterpret_cast<const void*>(0x1);

score 0 · Answer 4 · edited May 23 '17 at 12:06

An alternate solution which also comes from the question 40two references: constexpr and initialization of a static const void pointer with reinterpret cast, which compiler is right?, is to use intptr_t which is:

integer type capable of holding a pointer

This also allows you to make the member variable a constexpr:

class C
{
  public:
    static constexpr intptr_t noop = 0x1 ;
};

then you can use reinterpret_cast at the point where it is used:

const void * vPtr = reinterpret_cast<void*>( C::noop ) ;

Statically casting an integer to pointer type

4 Answers4

Linked