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.
