static_cast'd pointer value

  • A+
Category:Languages

In the current draft standard (and C++17), this is written about static_casting a void *:

A prvalue of type “pointer to cv1 void” can be converted to a prvalue of type “pointer to cv2 T”, where T is an object type and cv2 is the same cv-qualification as, or greater cv-qualification than, cv1. If the original pointer value represents the address A of a byte in memory and A does not satisfy the alignment requirement of T, then the resulting pointer value is unspecified. Otherwise, if the original pointer value points to an object a, and there is an object b of type T (ignoring cv-qualification) that is pointer-interconvertible with a, the result is a pointer to b. Otherwise, the pointer value is unchanged by the conversion.

I wonder, what is the difference whether the conversion is pointer-interconvertible or not? Is there a case, when casting a void * to something pointer-interconvertible actually changes the pointer value? What is the intent of this distinction?

For completeness pointer interconvertible:

Two objects a and b are pointer-interconvertible if:

  • (4.1) they are the same object, or
  • (4.2) one is a union object and the other is a non-static data member of that object ([class.union]), or
  • (4.3) one is a standard-layout class object and the other is the first non-static data member of that object, or, if the object has no non-static data members, any base class subobject of that object ([class.mem]), or
  • (4.4) there exists an object c such that a and c are pointer-interconvertible, and c and b are pointer-interconvertible.

If two objects are pointer-interconvertible, then they have the same address, and it is possible to obtain a pointer to one from a pointer to the other via a reinterpret_­cast.

 


You may misunderstand the term "pointer value". The term is defined in [basic.compound]/3:

Every value of pointer type is one of the following:

  • a pointer to an object or function (the pointer is said to point to the object or function), or

  • a pointer past the end of an object ([expr.add]), or

  • the null pointer value ([conv.ptr]) for that type, or

  • an invalid pointer value.

A value of a pointer type that is a pointer to or past the end of an object represents the address of the first byte in memory ([intro.memory]) occupied by the object or the first byte in memory after the end of the storage occupied by the object, respectively.

So you can see the term "pointer value" in the standard is a very abstract term. Even if two pointer values represent the same address, they may have different values. The example in cppreference demonstrates the concept of "pointer value" nicely:

struct S1 { int a; } s1; struct S2 { int a; private: int b; } s2; // not standard-layout union U { int a; double b; } u = {0}; int arr[2];  int* p1 = reinterpret_cast<int*>(&s1); // value of p1 is "pointer to s1.a" because s1.a                                        // and s1 are pointer-interconvertible  int* p2 = reinterpret_cast<int*>(&s2); // value of p2 is unchanged by reinterpret_cast and                                        // is "pointer to s2".   int* p3 = reinterpret_cast<int*>(&u);  // value of p3 is "pointer to u.a": u.a and u are                                        // pointer-interconvertible  double* p4 = reinterpret_cast<double*>(p3); // value of p4 is "pointer to u.b": u.a and u.b                                             // are pointer-interconvertible because both                                             // are pointer-interconvertible with u  int* p5 = reinterpret_cast<int*>(&arr); // value of p5 is unchanged by reinterpret_cast and                                         // is "pointer to arr" 

What is the intent of this distinction?

An important use of the concept of "pointer value" is to describe the strict aliasing rules formally (see also the standard [basic.lval]/11).

In the example above, p1 has value "pointer to s1.a" and has type int*, so, for example, *p1 is well-defined. On the other hand, p2 has value "pointer to s2" but has type int*, so *p2 is undefined.

Comment

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: