Re: stroustrup, void*, and reinterpret_cast
Francis Glassborow wrote:
In article <c4dea$4503d67b$8259a2fa$5933@news2.tudelft.nl>, Lourens
Veen <lourens@rainbowdesert.net> writes
struct A { /* ... */ }
struct B { /* ... */ }
struct C : public A, public B { /* ... */ }
int main() {
C c;
C * cp = &c;
A * ap = static_cast<A *>(&c);
B * bp = static_cast<B *>(&c);
}
If I call a member function on c through cp that modifies some
variable in the B subobject of c, then I will be able to see that
change through bp. So, conceptually, I'd argue that all the pointers
point to the same object.
In other words, the result of static_cast<B *>(&c) is a pointer of
type B * that points to c. The only difference between &c and
static_cast<B *>(&c) is that the type of the first expression is C
*, and the type of the second expression is B *. Their _value_ is
the same, namely "pointer to c", their types are different.
Sorry, IMHO that way madness lies. bp is a pointer to some B object
or subobject. The above code initialises it to a subobject of c. But
we can latter change it to point to some other B object. It does not
inherently point into a C object.
Maybe I'm mad then :). For what it's worth:
C is derived from B, so every C is a B. Hence c is a B, and bp can
point to it. If it does, bp probably won't hold the address of c but
some address inside c, but that doesn't make a difference
conceptually.
I know that C++ inheritance is not a strict type/subtype relationship
and that it violates the Liskov substitution principle, but I don't
think the idea is that outlandish.
Also, if B defined a virtual member function B::f() that was
overridden by C, how would you explain C::f() being called by bp->f()
if bp is pointing to a B subobject and doesn't know anything about
the C object that that B subobject it points to is part of?
I don't disagree with you that the address contained in bp may be
different from that contained in cp. It makes sense to implement it
that way and most if not all compilers do that. The problem is, we're
thinking on different levels. I'm talking about abstract concepts,
while you are talking about how they are implemented. The whole point
of static_cast over reinterpret_cast is that static_cast is defined
on that conceptual level, while reinterpret_cast requires knowledge
of implementation detail. That makes static_cast less dangerous than
reinterpret_cast.
Lourens
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]