static_cast 对 void* 的 const 引用

Question

I have a const reference to a void*:

void* p;
void* const& x = p;

I'd like to cast it to a const reference to a T* (for some struct T {}; ). Of the three ways I can think of doing this, my default choice of static_cast doesn't work:

T* const& y = static_cast<T* const&>(x);       // doesn't work
T* const& y = reinterpret_cast<T* const&>(x);  // works
T* const& y = (T* const&) x;                   // works

GCC gives the following error:

error: invalid static_cast from type ‘void* const’ to type ‘T* const&’
       T* const& y = static_cast<T* const&>(x);

I'd like to understand what it means, and if there is a way to fix it.

---

EDIT (2019-11-26):

There is a discussion in the comments and answers about whether T* const& (and void* const& ) is

1. a const reference to T* ; or
2. a reference to const T* .

The consensus in the comments seems to be that it's option 2. But from the following example, it seems to me that it's option 1.

Suppose I have a class T with a non-const function f() :

struct T
{
  void f() {};  // NB: non-const
};

We can consider two options:

const T*  x;
T* const& y;

Calling f() via them produces different effects:

x->f();   // compile-time error (passing ‘const T’ as ‘this’ argument discards qualifiers)
y->f();   // works fine

Does this not suggest that option 1 is correct? Can somebody reconcile this for me?

Answer 1

You can't bind a reference to any other type (except a less cv-qualified version of the same type or certain subtle things involving reading individual bytes via special types like unsigned char& ). If you force the matter with a reinterpret_cast (including via a C-style cast), it's undefined behavior to use the result (other than by casting it back).

You can (with merely static_cast ) convert a void* value to T* , and you can make conveniences like

const auto y=[&] {return static_cast<T*>(p);};

so that you can track p 's current value by writing y() anywhere later. (Since it returns by value, you indeed can't write y()=new T , as desired.)

Answer 2

That is how the language casts work. Here is a simple, lacking overview:

• const_cast Converts between types with different cv-qualification.
• static_cast is intended for safe casts. Integer conversions, conversion operators or conversion constructors are some example that static_cast can do.
• dynamic_cast is intended for polymorphism
• reinterpret_cast is a last resort option, allows basically any conversion by reinterpreting the underlying bit patterns.
• explicit C-style cast is considered a leftover from C. It will use the "best" cast in the context. In your example it is equivalent with reinterpret_cast .

Conversion from a void* to T* (both save cv) is valid iff the original pointer was of type T* aka at the pointed location there exists an object of type T . As you can see the conversion is "dangerous" in the sense that if the condition is not true you have UB (an invalid program). So you can only do that with reinterpret_cast .

Answer 3

Looking at your original problem of not wanting to modify a value via a certain pointer the following should work. Templating it should give the same result. Bring in references if you need to but it will have the same result.

void myfunc1(int* intptr)
{
    (*intptr)++;
    std::cout << "In myfunc1 "<< *intptr<<"\n";
}

void myfunc2(const int* intptr)
{
    //(*intptr)++; //modification not possible
    std::cout << "In myfunc2 " << *intptr << "\n";
}

int main()
{       
    int* val = new int;
    *val = 32;

    void*  p = val; 

    std::cout << "Before myfunc1 " << *val << "\n";
    myfunc1(static_cast<int*>(p));
    std::cout << "After myfunc1 "<<*val<<"\n";

    //no modification via pointer to const
    const int* x = static_cast<const int*>(p);
    myfunc2(x);
    std::cout << "After myfunc2 " << *val << "\n";

Answer 4

There's no const reference. In C++ references are not assignable (you can only initialize them). Also void* const& doesn't mean a const reference to void * . It instead means a reference to a const pointer to void. In the statement below you're just initializing a reference, so you don't need to mention reference in static_cast .

T* const& y = static_cast<T* const&>(x);

The correct form is:

T* const& y = static_cast<T* const>(x);

Update #1

There is a discussion in the comments and answers about whether T* const& (and void* const&) is

Neither 1 nor 2. Please note that const T* is different than T* const . Former is a non-const pointer to const T, whereas the latter is a const pointer to a non-const T. Thus, T* const& means a reference to a const pointer to a non-const T.

Also regarding the following example,

struct T
{
  void f() {};  // NB: non-const
};

given const T* x; , you cannot call x->f(); . because x is a pointer to const T but function f needs a non-const T, so you cannot initialize a non-const variable with a const variable as this discards const qualifier.