Re: Casting pointer to derived class and vice versa
Taras_96 wrote:
On Apr 25, 1:27 am, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
sk_usenet wrote:
"Taras_96" <taras...@gmail.com> wrote in message > Hi everyone,
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.
Could you explain the 'subojbects' bit a bit further? I think that's
the answer to my question. (in the code below, both Derived and Base
have one int member each)
Derived* pDerived = new Derived(); // pDerived points to a Derived
object
Base* pBase = static_cast<Base*>(pDerived); // address hasn't
changed
Derived* pDerived3 = static_cast<Derived*>(pBase); // address hasn't
changed
I found that casting to a base class (even though, AFAIK, the
static_cast isn't required), doesn't change the address, and neither
does casting back up to the Derived class.
Base* pBaseNext = new Derived();
Derived* pDerivedNext = static_cast<Derived*>(pBaseNext);
Both of these values are also the same.
So how come in my first example the values were changing?
Not all values are changing in the first example, I hope.
class Base1 {
int something;
};
class Base2 {
double whatever;
};
class Derived : public Base1, Base2 {
char whateverelse;
};
+------------Derived--------+
| +-----Base1-------------+ |
| | something | |
| +-----------------------+ |
| +-----Base2-------------+ |
| | whatever | |
| +-----------------------+ |
| whateverelse |
+---------------------------+
A 'Derived' object *consists* of a 'Base1' subobject, a 'Base2'
subobject, and of its own data member[s]. They cannot occupy the
same space, so they sit in their "container" (a 'Derived' object)
_sequentially_, often in the order of declaration. If 'Base1'
subobject has some size (and it would if it has to store its own
data, like 'something'), the address of 'Base1' and 'Base2' are
going to be different. Which one would be smaller is defined by
the declaration of them in the 'Derived'; in our case, since the
'Base1' class precedes 'Base2' in the inheritance part of the
'Derived' definition, the address of 'Base1' would be smaller
than 'Base2'. Now, since there is nothing in 'Derived' to go
before 'Base1', it is most likely that the 'Base1' subobject sits
right at the beginning of the 'Derived' object, in which it is
contained. That's why their addresses are the same.
Get yourself a copy of "Inside the C++ Object Model" by Lippman
if all this does not appear trivial. I don't own a copy, but
I hear that it's useful.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask