Where in the C++ spec is this allowed? It's cool. I want to know how this is spec'd. I didn't realize the spec allowed having a pointer to a undefined type.
class T;
int main(int argc, char* argv[])
{
int x;
T* p = reinterpret_cast<T*>(&x);
return 0;
}
The only thing you're allowed to do after casting a pointer to an unrelated type (other than char*), is cast back to the original pointer type.
@cli_hlt beat me to providing the section.
Here's the rule itself:
An object pointer can be explicitly converted to an object pointer of a different type. When a prvalue
vof type "pointer toT1" is converted to the type "pointer tocvT2", the result isstatic_cast<cv T2*>(static_cast<cv void*>(v))if bothT1andT2are standard-layout types (3.9) and the alignment requirements ofT2are no stricter than those ofT1, or if either type isvoid. Converting a prvalue of type "pointer toT1" to the type "pointer toT2" (whereT1andT2are object types and where the alignment requirements ofT2are no stricter than those ofT1) and back to its original type yields the original pointer value. The result of any other such pointer conversion is unspecified.
The strict aliasing rule prohibits access to an object through an unrelated type. See https://stackoverflow.com/a/7005988/103167
Another rule somewhat related to your question is found in section 5.4:
The operand of a cast using the cast notation can be a prvalue of type "pointer to incomplete class type". The destination type of a cast using the cast notation can be "pointer to incomplete class type" If both the operand and destination types are class types and one or both are incomplete, it is unspecified whether the
static_castor thereinterpret_castinterpretation is used, even if there is an inheritance relationship between the two classes.
What you're doing may be legal, but that depends on the real definition of class T, so we can't know for sure based on the code you've shown.
Starting with C++11 §3.9.2/3:
Pointers to incomplete types are allowed although there are restrictions on what can be done with them.
Those restrictions are listed in §3.2/4:
A class type
Tmust be complete if:
- an object of type
Tis defined, or- a non-static class data member of type
Tis declared, orTis used as the object type or array element type in a new-expression, or- an lvalue-to-rvalue conversion is applied to a glvalue referring to an object of type
T, or- an expression is converted (either implicitly or explicitly) to type
T, or- an expression that is not a null pointer constant, and has type other than
void*, is converted to the type pointer toTor reference toTusing an implicit conversion, adynamic_castor astatic_cast, or- a class member access operator is applied to an expression of type
T, or- the
typeidoperator or thesizeofoperator is applied to an operand of typeT, or- a function with a return type or argument type of type
Tis defined or called, or- a class with a base class of type
Tis defined, or- an lvalue of type
Tis assigned to, or- the type
Tis the subject of analignofexpression, or- an exception-declaration has type
T, reference toT, or pointer toT.
The 6th bullet appears pertinent here, as we can see in §5.2.10/7 that a reinterpret_cast between pointer types is defined in terms of static_cast:
An object pointer can be explicitly converted to an object pointer of a different type. When a prvalue
vof type “pointer toT1” is converted to the type “pointer to cvT2”, the result isstatic_cast<cv T2*>(static_cast<cv void*>(v))if bothT1andT2are standard-layout types and the alignment requirements ofT2are no stricter than those ofT1, or if either type isvoid. Converting a prvalue of type “pointer toT1” to the type “pointer toT2” (whereT1andT2are object types and where the alignment requirements ofT2are no stricter than those ofT1) and back to its original type yields the original pointer value. The result of any other such pointer conversion is unspecified.
But because reinterpret_cast static_casts to void* first, then to the real resulting pointer type, that 6th bullet doesn't apply.
So, so far you're still in legal territory, despite T being an incomplete type. However, if it turns out that T is not a standard-layout type or has stricter alignment requirements than int, then the last sentence in §5.2.10/7 holds true and you're invoking UB.
Section 5.2.10 (7) for your case (as of ISO/IEC14882:1998(E), as well as in the 2011 FDIS).
I'm not sure what you perceive as being allowed. There is a guarantee that you can reinterpret_cast from one pointer type to a sufficiently big other pointer type and back to the original type again and will be the original pointer. The specification for this is in 5.2.10 [expr.reinterpret.cast]. That is, the following is guaranteed to work:
T* ptr = ...;
S* sptr = reinterpret_cast<S*>(ptr);
T* tptr = reinterpret_cast<T*>(sptr);
assert(ptr == tptr);
We had an out of session discussion earlier this week on this topic: if the Death Station 9000 implementation (which would be a conforming implementation of C++ but also tries to break user code wherever it is allowed to do so) XORs the bit pattern of the pointer with a bit pattern randomly chosen at the beginning of the program execution, would this be a permissible implementation if the types involved in the reinterpret_cast<T>(x) are not involving char. The consensus was that this would be OK.
