By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
445,852 Members | 2,219 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 445,852 IT Pros & Developers. It's quick & easy.

About RTTI

P: n/a
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_cast"
conjunction will be much more efficient than "dynamic_cast",
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

Jul 19 '05 #1
Share this Question
Share on Google+
4 Replies


P: n/a
"Steven Lien" <st********@yahoo.com> wrote in message
news:bh**********@news.ethome.net.tw...
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_cast"
conjunction will be much more efficient than "dynamic_cast",
but what the book does not provide any evidence.
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.
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

Jul 19 '05 #2

P: n/a
"Steven Lien" <st********@yahoo.com> wrote...
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_cast"
conjunction will be much more efficient than "dynamic_cast",
but what the book does not provide any evidence.
Could it be because it's really nonsense?
So my question can any explain to me why dynmic_cast is slower than 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.
And since it's much slower, why not simply throw it away


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
Jul 19 '05 #3

P: n/a

Steven Lien <st********@yahoo.com> wrote in message
news:bh**********@news.ethome.net.tw...
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_cast"
conjunction will be much more efficient than "dynamic_cast",
but what the book does not provide any evidence.


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

-Mike

Jul 19 '05 #4

P: n/a
"Steven Lien" <st********@yahoo.com> wrote in message
news:bh**********@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_cast"
| conjunction will be much more efficient than "dynamic_cast",
| 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<Two*>(p) );
bool same2 = ( typeid(*p)==typeid(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<Base2*>(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



Jul 19 '05 #5

This discussion thread is closed

Replies have been disabled for this discussion.