About RTTI

[Steven Lien]

Hi all

As far as i know, there has 2 ways RTTI in C++
one is dynamic_cast and another is typeid

Since, my book only pointed me that to use "typeid" and "static_cas t"
conjunction will be much more efficient than "dynamic_ca st",
but what the book does not provide any evidence.

So my question can any explain to me why dynmic_cast is slower than typeid??

And since it's much slower, why not simply throw it away


Any Help will be appreciated

[Buster]

Re: About RTTI

"Steven Lien" <stevenlien@yah oo.com> wrote in message
news:bhtfdi$cjl $1@news.ethome. net.tw...[color=blue]
> Hi all
>
> As far as i know, there has 2 ways RTTI in C++
> one is dynamic_cast and another is typeid
>
> Since, my book only pointed me that to use "typeid" and "static_cas t"
> conjunction will be much more efficient than "dynamic_ca st",
> but what the book does not provide any evidence.[/color]

I don't think that's true in general. In the example given in your book,
is the pointer type-checked once then used many times? If so, a
static_cast to the known object type will be faster than repeated
dynamic_casts. But I would use dynamic_cast to perform the check
in the beginning, unless there were a good reason not to.
[color=blue]
> So my question can any explain to me why dynmic_cast is slower than typeid??
> And since it's much slower, why not simply throw it away
>
> Any Help will be appreciated[/color]

[Victor Bazarov]

Re: About RTTI

"Steven Lien" <stevenlien@yah oo.com> wrote...[color=blue]
> As far as i know, there has 2 ways RTTI in C++
> one is dynamic_cast and another is typeid
>
> Since, my book only pointed me that to use "typeid" and "static_cas t"
> conjunction will be much more efficient than "dynamic_ca st",
> but what the book does not provide any evidence.[/color]

Could it be because it's really nonsense?
[color=blue]
> So my question can any explain to me why dynmic_cast is slower than[/color]
typeid??

No. Because there is no such requirement or any evidence of that
in the language definition. You have to ask the authors of the
book you're referring to.
[color=blue]
> And since it's much slower, why not simply throw it away[/color]

Again, I am not sure where you got that "much slower" nonsense,
but I believe they both are in the language because they serve
different purposes.

Victor

[Mike Wahler]

Re: About RTTI


Steven Lien <stevenlien@yah oo.com> wrote in message
news:bhtfdi$cjl $1@news.ethome. net.tw...[color=blue]
> Hi all
>
> As far as i know, there has 2 ways RTTI in C++
> one is dynamic_cast and another is typeid
>
> Since, my book only pointed me that to use "typeid" and "static_cas t"
> conjunction will be much more efficient than "dynamic_ca st",
> but what the book does not provide any evidence.[/color]

Which book and author? Perhaps you need a better one.

-Mike

[Ivan Vecerina]

Re: About RTTI

"Steven Lien" <stevenlien@yah oo.com> wrote in message
news:bhtfdi$cjl $1@news.ethome. net.tw...
| As far as i know, there has 2 ways RTTI in C++
| one is dynamic_cast and another is typeid
|
| Since, my book only pointed me that to use "typeid" and "static_cas t"
| conjunction will be much more efficient than "dynamic_ca st",
| but what the book does not provide any evidence.
|
| So my question can any explain to me why dynmic_cast is slower than
typeid??
|
| And since it's much slower, why not simply throw it away

Slower at what ? They serve very different purposes.
Consider:

#include <typeinfo>

class One { public: virtual ~One(){} };
class Two : public One {};
class Three : public Two {};

void isThisATwo(One* p)
{
// which one of the following values do you want ???
bool same1 = ( 00 != dynamic_cast<Tw o*>(p) );
bool same2 = ( typeid(*p)==typ eid(Two) );
}

int main()
{
Three p;
isThisATwo(&p); // which result do you want?
}

dynamic_cast does a more exhaustive search, to tell you
whether an instance is of a specific type, *OR* any type
derived from it. typeid() cannot provide this information.



Additionally, dynamic_cast can perform casts that are
not accessible to static_cast:
class Base1 { public: virtual ~Base1(){} };
class Base2 { public: virtual ~Base2(){} };
class Derived : public Base1, public Base2 {};

void f(Base1* p1)
{
// can't be done with a static_cast...
Base2* p2 = dynamic_cast<Ba se2*>(p1);
}

int main()
{
Derived d;
f( &d );
}


Make sure to read other books about C++...


Regards,
--
Ivan Vecerina <> http://www.post1.com/~ivec
Brainbench MVP for C++ <> http://www.brainbench.com