Re: reinterpret cast and its affect on virtual functions
On 13 Feb., 08:19, Christopher <cp...@austin.rr.com> wrote:
If I have an abstract class A, and class B derives from A,
implementing A's pure virtual methods. What is supposed to happen when
somewhere in the code I reinterpret_cast a void * to a A *, then call
one of the pure virtual methods?
Of course such casting should be avoided if possible. A
reinterpret_cast is the last (worst) resort, really. Here your
programm will still be syntactically correct if you use a static_cast.
However, the standard only guarantees that
T* pointer;
static_cast<T*>(static_cast<void*>(pointer)) == pointer
In your case you probably have a situation like this:
B b; // 'b' is an A (public inheritance)
A pa1 = &b;
A pa2 = static_cast<A*>(static_cast<void*>(&b));
The question is: Is pa1==pa2 guaranteed?
I'm not 100% sure but I would say NO. The type "void*" simply doesn't
have enough information so the compiler can correctly adjust the
pointers if it has to.
B could be declared like this:
class B : public X, public A {...};
A compiler might lay out B im memory so that all members of X are at
the beginning and all members of A are at the end. A pointer to B is
likely to point to the beginning B (to the members of X). By using a
pointer conversion B* to A* the pointer is internally adjusted
accordingly. A static_cast is able to reverse this successfully (as
opposed to a reinterpret_cast IIRC). But if you have a void* as
intermediate pointer (which will point to the object's beginning -- in
this case the members of X) and convert it to A* you'll get undefined
behaviour when dereferencing.
Try to use "A*" instead of "void*" or at least make sure that the
source and target pointer type is exactly the same in a pointer
conversion with void* being an intermediate. Of course the latter
approach is error-prone.
Cheers!
SG