How dynamic_cast works internally?

[Bo Yang]

Hi,
I can understand static_cast, reinterpret_cas t and const_cast, they
all work at compile time. But I can figure out how the C++'s dynamic-
cast works? Could you please explain how for me?
Thanks in advance!

Regards!
Bo

[akshay.saidulu]

On Oct 22, 1:51 pm, Bo Yang <struggl...@gma il.comwrote:

Hi,
I can understand static_cast, reinterpret_cas t and const_cast, they
all work at compile time. But I can figure out how the C++'s dynamic-
cast works? Could you please explain how for me?
Thanks in advance!

Regards!
Bo

Dynamic cast adjests the offset adress of the perticul type
accordigly .if it does't find the type it will raise the exception (in
case of reference)or it will return null.
Ex:
class base{
};

class base1{
};
class derived : public base1,public base2{
};
deribed temp = new derived;
base2 *p = dynamic_cast<ba se2*temp;

it will adject the prt offset to base2 part of the temp object.

Br,
akshay saidulu

[Lance Diduck]

On Oct 22, 4:51 am, Bo Yang <struggl...@gma il.comwrote:

Hi,
I can understand static_cast, reinterpret_cas t and const_cast, they
all work at compile time. But I can figure out how the C++'s dynamic-
cast works? Could you please explain how for me?
Thanks in advance!

Regards!
Bo

Consider this case:
class A{virtual ~A(){};};
class B:public A{};
A*a=new B;
B*b =dynamic_cast<B *>(a);
Conceptually, it is like this if is were written in C:

void A_dtor(A* ){}
typeinfo A_RTTI(){
static typeinfo
return typeinfo("A");
}//compiler generated
void(*)() A_vtbl[]={A_dtor,A_RTTI };
struct A{
A_vtbl*vptr;
};
A_ctor(){vptr=A _vtbl;}//compiler generated

void B_dtor(B* ){}
typeinfo B_RTTI(){
static typeinfo
return typeinfo("B");
}//compiler generated
void(*)(B*) B_vtbl[]={B_dtor,B_RTTI };
struct B{
B_vtbl*vptr;
};
B_ctor(){vptr=B _vtbl;}//compiler generated

This is what A and B conceptually look like underneath the hood. Now
when dynamic_cast is called, the compiler generates a function
something like

B* Dynamic_Cast(A* a ){
if(*((a->vptr)+1)()==B_ RTTI())
return a;
return 0;
}

>From this, it is easy to extrapolate how this can be extended to work

for references.

You can see the reason now why dynamic_cast only works for types that
have "virtual" somewhere, either a function or inheritance.

Lance

[Greg Herlihy]

On Oct 22, 2:20 am, Lance Diduck <lancedid...@ny c.rr.comwrote:

On Oct 22, 4:51 am, Bo Yang <struggl...@gma il.comwrote:Hi,

I can understand static_cast, reinterpret_cas t and const_cast, they
all work at compile time. But I can figure out how the C++'s dynamic-
cast works? Could you please explain how for me?
Thanks in advance!

Regards!
Bo

Consider this case:
class A{virtual ~A(){};};
class B:public A{};
A*a=new B;
B*b =dynamic_cast<B *>(a);. .

B* Dynamic_Cast(A* a ){
if(*((a->vptr)+1)()==B_ RTTI())
return a;
return 0;

}

This implementation might work for typeid - because typeid has to
confirm only that type of the object being tested - matches the
specified type exactly.

A dynamic_cast operator however has to perform a much more complicated
test: whether an object (of unknown thype) is related to another type.
And to make do with a lot less information about the classes involved
than existed in the example above. For example:

struct A
{
virtual ~A() {}
};

bool TestA(void *p)
{
assert( p != NULL);
return dynamic_cast<A* >(p) != NULL;
}

Note that no derived classes of A (if any exist) are visible when this
source file is compiled. So no matter how many large or complex this
program's class hierarchy might be, dynamic_cast<ha s only the "A"
class declaration with which to work here.

So how is dynamic_cast<su pposed to figure out whether p points to a
type that is somehow related to A? Well, given these constraints,
there is only one way to solve this problem. dynamic_cast must search
p's class hierarchy (essentially, discovering its layout as it goes
along) and to continue the search until either a A class is located
with the hierarchy - or there are no other classes left in the
hierarchy that need to be checked.

Greg

[Bo Yang]

ak************@ gmail.com ]:

On Oct 22, 1:51 pm, Bo Yang <struggl...@gma il.comwrote:

>Hi,
I can understand static_cast, reinterpret_cas t and const_cast, they
all work at compile time. But I can figure out how the C++'s dynamic-
cast works? Could you please explain how for me?
Thanks in advance!

Regards!
Bo

Dynamic cast adjests the offset adress of the perticul type
accordigly .if it does't find the type it will raise the exception (in
case of reference)or it will return null.
Ex:
class base{
};

class base1{
};
class derived : public base1,public base2{
};
deribed temp = new derived;
base2 *p = dynamic_cast<ba se2*temp;

it will adject the prt offset to base2 part of the temp object.

Does it just adject the pointer without any additional check of type?

Regards!
Bo

[Bo Yang]

Lance Diduck:

Consider this case:
class A{virtual ~A(){};};
class B:public A{};
A*a=new B;
B*b =dynamic_cast<B *>(a);
Conceptually, it is like this if is were written in C:

void A_dtor(A* ){}
typeinfo A_RTTI(){
static typeinfo
return typeinfo("A");
}//compiler generated
void(*)() A_vtbl[]={A_dtor,A_RTTI };
struct A{
A_vtbl*vptr;
};
A_ctor(){vptr=A _vtbl;}//compiler generated

void B_dtor(B* ){}
typeinfo B_RTTI(){
static typeinfo
return typeinfo("B");
}//compiler generated
void(*)(B*) B_vtbl[]={B_dtor,B_RTTI };
struct B{
B_vtbl*vptr;
};
B_ctor(){vptr=B _vtbl;}//compiler generated

This is what A and B conceptually look like underneath the hood. Now
when dynamic_cast is called, the compiler generates a function
something like

B* Dynamic_Cast(A* a ){
if(*((a->vptr)+1)()==B_ RTTI())
return a;
return 0;
}

Thank you for your detailed explaination. And you mean all dynamic_cast
use RTTI inside. yes?

>>From this, it is easy to extrapolate how this can be extended to work

for references.

You can see the reason now why dynamic_cast only works for types that
have "virtual" somewhere, either a function or inheritance.

Yes, class with no virtual has no virtual table at all.

Thanks!

Regards!
Bo

[Bo Yang]

Greg Herlihy :

On Oct 22, 2:20 am, Lance Diduck <lancedid...@ny c.rr.comwrote:

>On Oct 22, 4:51 am, Bo Yang <struggl...@gma il.comwrote:Hi,

>> I can understand static_cast, reinterpret_cas t and const_cast, they
all work at compile time. But I can figure out how the C++'s dynamic-
cast works? Could you please explain how for me?
Thanks in advance!
Regards!
Bo

Consider this case:
class A{virtual ~A(){};};
class B:public A{};
A*a=new B;
B*b =dynamic_cast<B *>(a);. .

>B* Dynamic_Cast(A* a ){
if(*((a->vptr)+1)()==B_ RTTI())
return a;
return 0;

}

This implementation might work for typeid - because typeid has to
confirm only that type of the object being tested - matches the
specified type exactly.

A dynamic_cast operator however has to perform a much more complicated
test: whether an object (of unknown thype) is related to another type.
And to make do with a lot less information about the classes involved
than existed in the example above. For example:

struct A
{
virtual ~A() {}
};

bool TestA(void *p)
{
assert( p != NULL);
return dynamic_cast<A* >(p) != NULL;
}

Note that no derived classes of A (if any exist) are visible when this
source file is compiled. So no matter how many large or complex this
program's class hierarchy might be, dynamic_cast<ha s only the "A"
class declaration with which to work here.

So how is dynamic_cast<su pposed to figure out whether p points to a
type that is somehow related to A? Well, given these constraints,
there is only one way to solve this problem. dynamic_cast must search
p's class hierarchy (essentially, discovering its layout as it goes
along) and to continue the search until either a A class is located
with the hierarchy - or there are no other classes left in the
hierarchy that need to be checked.

So, how C++ go along the classes hierarchy at runtime? RTTI? Is RTTI a
standard of C++? I think RTTI is not a standard part of C++!

Regards!
Bo

[dasjotre]

On Oct 22, 10:20 am, Lance Diduck <lancedid...@ny c.rr.comwrote:

You can see the reason now why dynamic_cast only works for types that
have "virtual" somewhere, either a function or inheritance.

only for upcast.

downcast must work too regardless to
virtuals:

struct B{};
struct D : B {};
D d;
B & b = dynamic_cast<B& >(d); // OK,
B & b1 = d; // is OK too ;)

DS

[Pete Becker]

On 2007-10-22 09:19:26 -0400, Bo Yang <st********@gma il.comsaid:

>
So, how C++ go along the classes hierarchy at runtime? RTTI? Is RTTI a
standard of C++? I think RTTI is not a standard part of C++!

Well, yes, there is no specification of anything called RTTI in the
language definition. But RTTI is shorthand for the usual implementation
technique for dynamic_cast and for catching exceptions. The compiler
generates type information that's used at runtime to match types as
needed. Hence, RunTime Type Information.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2007-10-22 15:19, Bo Yang wrote:

Greg Herlihy :

>On Oct 22, 2:20 am, Lance Diduck <lancedid...@ny c.rr.comwrote:

>>On Oct 22, 4:51 am, Bo Yang <struggl...@gma il.comwrote:Hi,
I can understand static_cast, reinterpret_cas t and const_cast, they
all work at compile time. But I can figure out how the C++'s dynamic-
cast works? Could you please explain how for me?
Thanks in advance!
Regards!
Bo
Consider this case:
class A{virtual ~A(){};};
class B:public A{};
A*a=new B;
B*b =dynamic_cast<B *>(a);. .

>>B* Dynamic_Cast(A* a ){
if(*((a->vptr)+1)()==B_ RTTI())
return a;
return 0;

}

This implementation might work for typeid - because typeid has to
confirm only that type of the object being tested - matches the
specified type exactly.

A dynamic_cast operator however has to perform a much more complicated
test: whether an object (of unknown thype) is related to another type.
And to make do with a lot less information about the classes involved
than existed in the example above. For example:

struct A
{
virtual ~A() {}
};

bool TestA(void *p)
{
assert( p != NULL);
return dynamic_cast<A* >(p) != NULL;
}

Note that no derived classes of A (if any exist) are visible when this
source file is compiled. So no matter how many large or complex this
program's class hierarchy might be, dynamic_cast<ha s only the "A"
class declaration with which to work here.

So how is dynamic_cast<su pposed to figure out whether p points to a
type that is somehow related to A? Well, given these constraints,
there is only one way to solve this problem. dynamic_cast must search
p's class hierarchy (essentially, discovering its layout as it goes
along) and to continue the search until either a A class is located
with the hierarchy - or there are no other classes left in the
hierarchy that need to be checked.

So, how C++ go along the classes hierarchy at runtime? RTTI? Is RTTI a
standard of C++? I think RTTI is not a standard part of C++!

RTTI is part of the C++ standard, do not confuse it with reflection
though. One way to accomplish this (though I do not think that is how it
is done) would be to add a second pointer (in addition to the vtable)
which points to a type object looking something like this:

class Type
{
char name[];
Type* super[];
Type* derived[];
};

That way typeid could (conceptually) be implemented something like this:

template<typena me T>
type_info typeid(T t)
{
return type_info(t->typePtr->name)
}

And using some simple tree walking algorithms you can find out if a type
is in the same type-hierarchy as another.

--
Erik Wikström