UPDATE: I do appreciate "don't want that, want this instead" suggestions. They are useful, especially when provided in context of the motivating scenario. Still...regardless of goodness/badness, I've become curious
to find a hard-and-fast "yes that can be done legally in C++11" vs "no it is not possible
to do something like that".
I want
to "alias" an
object pointer as another type, for the sole purpose of adding some helper methods. The alias cannot add data members
to the underlying class (in fact, the more I can prevent that from happening the better!) All aliases are equally applicable
to any
object of this type...it's just helpful if the type system can hint which alias is likely the most appropriate.
There should be no information about any specific alias that is ever encoded in the underlying
object. Hence, I feel like you should be able
to "cheat" the type system and just let it be an annotation...checked at compile time, but ultimately irrelevant
to the runtime casting. Something along these lines:
Node<AccessorFoo>* fooPtr = Node<AccessorFoo>::createViaFactory();
Node<AccessorBar>* barPtr = reinterpret_cast< Node<AccessorBar>* >(fooPtr);
Under the hood, the factory method is actually making a NodeBase class, and then using a similar reinterpret_cast
to return it as a Node<AccessorFoo>*.
The easy way
to avoid this is
to make these lightweight classes that wrap nodes and are passed around by value. Thus you don't need casting, just Accessor classes that take the node handle
to wrap in their constructor:
AccessorFoo foo (NodeBase::createViaFactory());
AccessorBar bar (foo.getNode());
But if I don't have
to pay for all that, I don't want
to. That would involve--for instance--making a special accessor type for each sort of wrapped pointer (AccessorFooShared, AccessorFooUnique, AccessorFooWeak, etc.) Having these typed pointers being aliased for one single pointer-based
object identity is preferable, and provides a nice orthogonality.
So back
to that original question:
Node<AccessorFoo>* fooPtr = Node<AccessorFoo>::createViaFactory();
Node<AccessorBar>* barPtr = reinterpret_cast< Node<AccessorBar>* >(fooPtr);
Seems like there would be some way
to do this that might be ugly but not "break the rules". According
to ISO14882:2011(e) 5.2.10-7:
An
object pointer can be explicitly converted
to an
object pointer of a different type.70 When a prvalue v of type "pointer
to T1" is converted
to the type "pointer
to cv T2", the result is static_cast(static_cast(v)) if both T1 and T2 are standard-layout types (3.9) and the alignment requirements of T2 are no stricter than those of T1, or if either type is void. Converting a prvalue of type "pointer
to T1"
to the type "pointer
to T2" (where T1 and T2 are
object types and where the alignment requirements of T2 are no stricter than those of T1) and back
to its original type yields the original pointer value. The result of any other such pointer conversion is unspecified.
Drilling into the definition of a "standard-layout class", we find:
has no non-static data members of type non-standard-layout-class (or array of such types) or reference, and
has no virtual functions (10.3) and no virtual base classes (10.1), and
has the same access control (clause 11) for all non-static data members, and
has no non-standard-layout base classes, and
either has no non-static data member in the most-derived class and at most one base class with non-static data members, or has no base classes with non-static data members, and
has no base classes of the same type as the first non-static data member.
Sounds like working with something like this would tie my hands a bit with no virtual methods in the accessors or the node. Yet C++11 apparently has std::is_standard_layout
to keep things checked.
Can this be done safely? Appears
to work in gcc-4.7, but I'd like
to be sure I'm not invoking undefined behavior.
