Re: Casting pointer to derived class and vice versa
sk_usenet wrote:
"Taras_96" <taras.di@gmail.com> wrote in message > Hi everyone,
I was experimenting with static_cast and reinterpret cast
#include <iostream>
struct A1 { int a; };
struct A2 { double d; };
struct B : public A1, A2
{
int v;
};
int main()
{
// one B object
B b;
// two A2 pointers
A2 * p1;
A2 * p2;
// set both pointers to &b
p1 = static_cast<A2*>(&b);
p2 = reinterpret_cast<A2*>(&b);
// same type, same B object...
// but point to different addresses:
std::cout << "p1: " << p1 << "\n";
std::cout << "p2: " << p2 << "\n";
// the pointers are not equal
assert (p1 == p2); // fails
}
Program Output:
p1: 0xbffff97c
p2: 0xbffff978
Assertion failed: (p1 == p2), function main, file test.cc, line
30.
Abort trap
AFAICT, the difference between the two casts is that static_cast
knows that you're casting down, so it adjusts the value of the
pointer
Where are you casting down?
The meaning of "Down" and "Up" is open for debate. Some consider
the root of the tree to be at the top. I've never seen a real tree
like that. Heard of it, but never seen one.
accordingly. reinterpret_cast is just a brute cast.
static_cast would make the derived class pointer point to the
appropriate base class (as laid out in memory), hence you see
different values.
"Hence"? There is no 'static_cast' required to convert from the
derived class to the accessible unambiguous base class. And the
different values are only because the sizes of the base class
subobjects are not 0, so they occupy some space in the derived
class object. Using 'reinterpret_cast' in this situation is
simply not legal.
reinterpret_cast is just a reinterpretation of the
bits. Of course this is implementation defined. You could check
"Inside the C++ Object Model" book by Lippman for more details.
[snip]
Is this even defined in C++, or is it implementation specific?
Implementation defined.
Interestingly when you assign a derived pointer to a base pointer,
the value stored doesn't change, even with a static_cast. This is
more inline with how I thought pointers would originally behave.
What? Is this in line with what you saw in your sample program?
So casting from a base to a derived will change the value stored by
the pointer, but casting (or assigning) from a derived to a base will
not change the value. Is there a reason for this?
Check dynamic_cast for downcasting.
Again, you seem to use different meaning of "down-" or "up-" AFA
casting is concerned. And 'dynamic_cast' is NOT going to work
here because the classes are not polymorphic. And, BTW, even for
what you call "downcasting", static_cast is perfectly OK:
B b;
A1 *pa1 = &b;
A2 *pa2 = &b;
B *pb1 = static_cast<B*>(pa1);
B *pb2 = static_cast<B*>(pa2);
assert(pb1 == pb2);
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask