424,961 Members | 1,388 Online
Need help? Post your question and get tips & solutions from a community of 424,961 IT Pros & Developers. It's quick & easy.

# I don't get it

 P: n/a class A { public: char text_a[100]; A() { *text_a=0; } ~A() {} }; //----------------------------------------------------------------------------- class B { public: char text_b[100]; B() { *text_b=0; } ~B() {} }; //----------------------------------------------------------------------------- class C : public A, public B { public: char text_c[100]; C() { *text_c=0; } ~C() {} }; //------------------------------------------------------------------------------- void test() { B *bp1,*bp2; C c,*cp1,*cp2,*cp3; void *p; strcpy(c.text_a,"hello a"); strcpy(c.text_b,"hello b"); strcpy(c.text_c,"hello c"); cp1=&c; p=cp1; bp1=cp1; // ok bp2=(B*)p; // resulting bp2 is WRONG! cp2=(C*)p; // ok cp3=(C*)bp2; // resulting cp3 is WRONG! Which is logical because bp2 is already wrong. } //----------------------------------------------------------------------------- So the hot spot is the bp2=(B*)p; What's wrong with that??? I can imagine someone saying "p is not pointing to a B object". But if you think about it, conceptually, it does, imho. So is it more a technical matter of compiling this!? Maybe i'm stupid and/or missing something essential about C++. If so, please give me a link to where i can study this right. Cheers, Jo Jun 18 '07 #1
31 Replies

 P: n/a On Jun 18, 11:17 am, Jo >a; } I printed the value in p and also in bp2. Both are one and the same. On my m/c the O/P was - 0x22fe28 0x22fe28 Why do you think, in your program, resulting bp2 is WRONG? Jun 18 '07 #2

 P: n/a Bharath wrote: >On Jun 18, 11:17 am, Jo >class A { public: char text_a[100]; A() { *text_a=0; } ~A() {}};//-----------------------------------------------------------------------------class B { public: char text_b[100]; B() { *text_b=0; } ~B() {}};//-----------------------------------------------------------------------------class C : public A, public B { public: char text_c[100]; C() { *text_c=0; } ~C() {}};//-------------------------------------------------------------------------------void test() {B *bp1,*bp2;C c,*cp1,*cp2,*cp3;void *p; strcpy(c.text_a,"hello a"); strcpy(c.text_b,"hello b"); strcpy(c.text_c,"hello c"); cp1=&c; p=cp1; bp1=cp1; // ok bp2=(B*)p; // resulting bp2 is WRONG! cp2=(C*)p; // ok cp3=(C*)bp2; // resulting cp3 is WRONG! Which is logical because bp2is already wrong.}//-----------------------------------------------------------------------------So the hot spot is the bp2=(B*)p;What's wrong with that???I can imagine someone saying "p is not pointing to a B object".But if you think about it, conceptually, it does, imho.So is it more a technical matter of compiling this!?Maybe i'm stupid and/or missing something essential about C++.If so, please give me a link to where i can study this right.Cheers,Jo I re-wrote your test function like this -int main() {B *bp1,*bp2;C c,*cp1;void *p;int a; strcpy(c.text_a,"hello a"); strcpy(c.text_b,"hello b"); strcpy(c.text_c,"hello c"); cp1=&c; p=cp1; bp2=(B*)p; std::cout<>a;}I printed the value in p and also in bp2. Both are one and the same.On my m/c the O/P was -0x22fe280x22fe28Why do you think, in your program, resulting bp2 is WRONG? Because i got runtime problems. So i narrowed down everything to the above code. Running this on my PC gives a wrong bp2 pointer. I can see it in the "Watch" panel. And i also did a similar thing than you: at the end of the test/main function i did a OutputDebugString(cp3->text_a); OutputDebugString(cp3->text_b); OutputDebugString(cp3->text_c); This gives rubbish for text a!!! Compilation is done with Visual C++ 7.1.3088 Jun 18 '07 #3

 P: n/a Jo wrote: class A { public: char text_a[100]; A() { *text_a=0; } ~A() {} }; //----------------------------------------------------------------------------- class B { public: char text_b[100]; B() { *text_b=0; } ~B() {} }; //----------------------------------------------------------------------------- class C : public A, public B { public: char text_c[100]; C() { *text_c=0; } ~C() {} }; //------------------------------------------------------------------------------- void test() { B *bp1,*bp2; C c,*cp1,*cp2,*cp3; void *p; strcpy(c.text_a,"hello a"); strcpy(c.text_b,"hello b"); strcpy(c.text_c,"hello c"); cp1=&c; p=cp1; bp1=cp1; // ok bp2=(B*)p; // resulting bp2 is WRONG! cp2=(C*)p; // ok cp3=(C*)bp2; // resulting cp3 is WRONG! Which is logical because bp2 is already wrong. } //----------------------------------------------------------------------------- So the hot spot is the bp2=(B*)p; What's wrong with that??? I can imagine someone saying "p is not pointing to a B object". Right. But if you think about it, conceptually, it does, imho. No, it doesn't. > So is it more a technical matter of compiling this!? No the code is wrong. > Maybe i'm stupid and/or missing something essential about C++. I doubt you're stupid but you're certainly missing something essential. > If so, please give me a link to where i can study this right. I have no idea why you think that code should be right, that is my problem. Perhaps you are expecting an ordinary cast to work like a dynamic_cast? When you write bp2=(B*)p; // resulting bp2 is WRONG! you are expecting the program to 'discover' that there a B object hidden inside the object that p is pointing to? If so google for dynamic_cast, or better still read a good book. john Jun 18 '07 #4

 P: n/a Jo What's probably happening in your case is that the memory layout of your object is A->B->C. So when you take your C* (which is effectively also an A*, but is _not_ a B*...), hammer it into a void*, and then re-form it as a B*, you are effectively casting an A* to a B*. Since they're unrelated types, who knows what the operations on B do to an A object. So.. you should cast that void* to a C* first, then assign the C* to a B* (no cast required). The compiler will know at that point that you're upcasting and will adjust the pointer value accordingly. Jun 18 '07 #5

 P: n/a John Harrison wrote: Jo wrote: >class A { public: char text_a[100]; A() { *text_a=0; } ~A() {}};//-----------------------------------------------------------------------------class B { public: char text_b[100]; B() { *text_b=0; } ~B() {}};//-----------------------------------------------------------------------------class C : public A, public B { public: char text_c[100]; C() { *text_c=0; } ~C() {}};//-------------------------------------------------------------------------------void test() {B *bp1,*bp2;C c,*cp1,*cp2,*cp3;void *p; strcpy(c.text_a,"hello a"); strcpy(c.text_b,"hello b"); strcpy(c.text_c,"hello c"); cp1=&c; p=cp1; bp1=cp1; // ok bp2=(B*)p; // resulting bp2 is WRONG! cp2=(C*)p; // ok cp3=(C*)bp2; // resulting cp3 is WRONG! Which is logical because bp2is already wrong.}//----------------------------------------------------------------------------- So the hot spot is the bp2=(B*)p;What's wrong with that???I can imagine someone saying "p is not pointing to a B object". Right. >But if you think about it, conceptually, it does, imho. No, it doesn't. >>So is it more a technical matter of compiling this!? No the code is wrong. >>Maybe i'm stupid and/or missing something essential about C++. I doubt you're stupid but you're certainly missing something essential. >>If so, please give me a link to where i can study this right. I have no idea why you think that code should be right, that is my problem. Imho, if class C is derived from A and B, then C IS an A and a B at the same time, conceptually. But i'm understanding that there is a technical implementation problem here. I thought the compiler could figure that out, but i'm clearly over estimating the compiler and/or C++. Anyway, it's off topic to go deeper in this. Although that would be a nice discussion. So i'll focus on the practical problem here. Perhaps you are expecting an ordinary cast to work like a dynamic_cast? When you write bp2=(B*)p; // resulting bp2 is WRONG! you are expecting the program to 'discover' that there a B object hidden inside the object that p is pointing to? If so google for dynamic_cast, or better still read a good book. I understand that a dynamic_cast cannot do a base-to-derived conversion, so that's not the solution here. And a static_cast doesn't seem to make any difference, because i'm already doing static casts right, just in the 'old' way. So i'm still looking for the solution for this situation class A { public: virtual long GetClassID() { return(' A'); } }; class B { public: // some class data & funx }; class C : public class A, public class B { public: virtual long GetClassID() { return(' C'); } }; foo1(C *cp) { ... foo2(cp); ... } foo2(A *ap) { if (ap->GetClassID==' C') { C *cp=(C*)ap; // IS THIS LEGAL and PORTABLE C++ ? } } Jun 18 '07 #7

 P: n/a class A { public: char text_a[100]; A() { *text_a=0; } ~A() {} }; //----------------------------------------------------------------------------- class B { public: char text_b[100]; B() { *text_b=0; } ~B() {} }; //----------------------------------------------------------------------------- class C : public A, public B { public: char text_c[100]; C() { *text_c=0; } ~C() {} }; //----------------------------------------------------------------------------- In the context of pointer casting: Does it matter for ansi C++ if class C is derived from A then B, or from B then A ? Jun 18 '07 #8

 P: n/a >If so google for dynamic_cast, or better still read a good book. I understand that a dynamic_cast cannot do a base-to-derived conversion, so that's not the solution here. dynamic_cast does do base to derived conversion, that's it's main use. Where are you getting your information? john Jun 18 '07 #9

 P: n/a //----------------------------------------------------------------------------- > class C : public A, public B { public: char text_c[100]; C() { *text_c=0; } ~C() {} }; //----------------------------------------------------------------------------- In the context of pointer casting: Does it matter for ansi C++ if class C is derived from A then B, or from B then A ? No it doesn't matter. john Jun 18 '07 #10

 P: n/a Jo wrote: > Imho, if class C is derived from A and B, then C IS an A and a B at the same time, conceptually. But i'm understanding that there is a technical implementation problem here. I thought the compiler could figure that out, but i'm clearly over estimating the compiler and/or C++. The compiler can, indeed, figure out the relation between a C*, the corresponding A*, and the corresponding B*. The problem is that you're not dealing with a C*, but with a void*. The code tells the compiler that p points to untyped data, and that it should treat the address of that untyped data as the address of an object of type B. The compiler did exactly what you told it to do. The only valid conversion you can apply to that void* is to cast it back to the type of the original pointer. (C*)p, as you've seen, works just fine. (B*)(C*)p would give you the address of the B subobject. -- -- Pete Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The Standard C++ Library Extensions: a Tutorial and Reference." (www.petebecker.com/tr1book) Jun 18 '07 #11

 P: n/a Jo wrote: Imho, if class C is derived from A and B, then C IS an A and a B at the same time, conceptually. But i'm understanding that there is a technical implementation problem here. In the OP you tried to get a B* from a void*. A void pointer is everything and nothing, the compiler cannot know what type of object it points to. So avoid void*. Avoid c-style cast, too. With C++ style cast, the compiler can warn you whats wrong using them. I thought the compiler could figure that out, but i'm clearly over estimating the compiler and/or C++. Anyway, it's off topic to go deeper in this. Although that would be a nice discussion. When it's a language thing, it is on-topic. >Perhaps you are expecting an ordinary cast to work like adynamic_cast? When you writebp2=(B*)p; // resulting bp2 is WRONG!you are expecting the program to 'discover' that there a B objecthidden inside the object that p is pointing to?If so google for dynamic_cast, or better still read a good book. I understand that a dynamic_cast cannot do a base-to-derived conversion, so that's not the solution here. dynamic_cast can, and is exactly the right tool, to do base-to-derived conversion. It's like static_cast with an explicit runtime type check. So i'm still looking for the solution for this situation class A { public: virtual long GetClassID() { return(' A'); } }; [...] class C : public class A, public class B { public: virtual long GetClassID() { return(' C'); } }; foo1(C *cp) { ... foo2(cp); ... } foo2(A *ap) { if (ap->GetClassID==' C') { C *cp=(C*)ap; // IS THIS LEGAL and PORTABLE C++ ? } } When you know that an A* points to a C object, you can static_cast it to a C*. But why inventing your own RTTI? You can use typeid and dynamic_cast instead. -- Thomas http://www.netmeister.org/news/learn2quote.html Jun 18 '07 #12

 P: n/a John Harrison wrote: > >>If so google for dynamic_cast, or better still read a good book. I understand that a dynamic_cast cannot do a base-to-derivedconversion, so that's not the solution here. dynamic_cast does do base to derived conversion, that's it's main use. Where are you getting your information? I got that from http://www.cplusplus.com/doc/tutorial/typecasting.html But i was just reading another webpage where they indeed use base-to-derived dynamic casts... Did i misunderstand the cplusplus page? Anyway, i prefer not to use RTTI. Jun 18 '07 #13

 P: n/a Pete Becker wrote: Jo wrote: >>Imho, if class C is derived from A and B, then C IS an A and a B atthe same time, conceptually.But i'm understanding that there is a technical implementationproblem here.I thought the compiler could figure that out, but i'm clearly overestimating the compiler and/or C++. The compiler can, indeed, figure out the relation between a C*, the corresponding A*, and the corresponding B*. The problem is that you're not dealing with a C*, but with a void*. The code tells the compiler that p points to untyped data, and that it should treat the address of that untyped data as the address of an object of type B. The compiler did exactly what you told it to do. The only valid conversion you can apply to that void* is to cast it back to the type of the original pointer. (C*)p, as you've seen, works just fine. (B*)(C*)p would give you the address of the B subobject. So the very problem was the void*, right? So is all this correct then: (supposing the same class hierarchy as before, where C is derived from A and B) C *cp=new C; B *bp=cp; C *cp2=(C*)bp; A *ap=(A*)bp; Jun 18 '07 #14

 P: n/a Jo Jo wrote: [snip] >Perhaps you are expecting an ordinary cast to work like adynamic_cast? When you writebp2=(B*)p; // resulting bp2 is WRONG!you are expecting the program to 'discover' that there a B objecthidden inside the object that p is pointing to?If so google for dynamic_cast, or better still read a good book. I understand that a dynamic_cast cannot do a base-to-derived conversion, so that's not the solution here. No, that's exactly what dynamic_cast is for, _if_ the pointer is pointing to an object that actually is of the derived type. And a static_cast doesn't seem to make any difference, because i'm already doing static casts right, just in the 'old' way. So i'm still looking for the solution for this situation class A { public: virtual long GetClassID() { return(' A'); } }; class B { public: // some class data & funx }; class C : public class A, public class B { public: virtual long GetClassID() { return(' C'); } }; foo1(C *cp) { ... foo2(cp); ... } foo2(A *ap) { if (ap->GetClassID==' C') { C *cp=(C*)ap; // IS THIS LEGAL and PORTABLE C++ ? } } In theory that would work... of course so would: class A { virtual ~A() {}; }; class B { virtual ~B() {}; }; class C : public class A, public class B { virtual ~C() {}; void cfn() {}; }; foo1(C *cp) { fooA(cp); } fooA(A *ap) { C * cp = dynamic_cast(ap); if (cp != NULL) { cp->cfn(); } } No "getclassid" function required. However, note that there's no mention of B anywhere in there (other than the inheritance).... so how does B get involved in this question? Jun 18 '07 #16

 P: n/a Thomas J. Gritzan wrote: >Jo wrote: >>Imho, if class C is derived from A and B, then C IS an A and a B at thesame time, conceptually.But i'm understanding that there is a technical implementation problemhere. In the OP you tried to get a B* from a void*. A void pointer is everythingand nothing, the compiler cannot know what type of object it points to. OK, understood. >So avoid void*. Avoid c-style cast, too. With C++ style cast, the compilercan warn you whats wrong using them. OK, will take this into account. >>I thought the compiler could figure that out, but i'm clearly overestimating the compiler and/or C++.Anyway, it's off topic to go deeper in this. Although that would be anice discussion. When it's a language thing, it is on-topic. The point was: When C is derived from A and B, then C is an A and C is a B at the same time. I would have been surprised if C++/the compiler would not be able to do the up/down casts in this family, even when multiple inheritance is into play. (i immediately thought of a system how this would be no problem) For a moment, i thought John said that C is not a B. But i misunderstood. Now i understand he said that the void* p is not pointing to the B object (in the given example) which is right because it's a void*. If the C++ compiler can figure out the A/B/C up/down casts, then of course i keep on being a happy C++ -er. I know all this is pure essential. I'm a bit amazed/ashamed that i ran into this problem (i.e. using the void*). I didn't know that when using a void*, you explicitly abandon all type info, except for the source type. >>>Perhaps you are expecting an ordinary cast to work like adynamic_cast? When you writebp2=(B*)p; // resulting bp2 is WRONG!you are expecting the program to 'discover' that there a B objecthidden inside the object that p is pointing to?If so google for dynamic_cast, or better still read a good book. I understand that a dynamic_cast cannot do a base-to-derived conversion,so that's not the solution here. dynamic_cast can, and is exactly the right tool, to do base-to-derivedconversion. It's like static_cast with an explicit runtime type check. I understand. >>So i'm still looking for the solution for this situationclass A {public:virtual long GetClassID() { return(' A'); }}; [...] >>class C : public class A, public class B {public:virtual long GetClassID() { return(' C'); }}; foo1(C *cp) {...foo2(cp);...}foo2(A *ap) {if (ap->GetClassID==' C') { C *cp=(C*)ap; // IS THIS LEGAL and PORTABLE C++ ?}} When you know that an A* points to a C object, you can static_cast it to aC*. But why inventing your own RTTI? You can use typeid and dynamic_castinstead. It's indeed about having a 'little private' RTTI system. I would like to not use RTTI because i heard about the overhead it brings. Not sure if that is memory or cpu overhead, or both? The application i'm working on is a multi-threaded realtime application where part of the code runs at interrupt level. And that code must be fast, and may not do any dynamic memory allocs! So that's why i want to play it safe. Jun 18 '07 #17

 P: n/a On 2007-06-18 22:17, Jo wrote: John Harrison wrote: >> >>>If so google for dynamic_cast, or better still read a good book. I understand that a dynamic_cast cannot do a base-to-derivedconversion, so that's not the solution here. dynamic_cast does do base to derived conversion, that's it's main use.Where are you getting your information? I got that from http://www.cplusplus.com/doc/tutorial/typecasting.html But i was just reading another webpage where they indeed use base-to-derived dynamic casts... Did i misunderstand the cplusplus page? Yes, it seems to me like they perform a base to derived cast there (second example), though their example are perhaps a bit more complicated than needed. -- Erik Wikström Jun 18 '07 #18

 P: n/a Andre Kostur wrote: >Jo >John Harrison wrote: >>>Jo wrote: [snip] >>>Perhaps you are expecting an ordinary cast to work like adynamic_cast? When you writebp2=(B*)p; // resulting bp2 is WRONG!you are expecting the program to 'discover' that there a B objecthidden inside the object that p is pointing to?If so google for dynamic_cast, or better still read a good book. I understand that a dynamic_cast cannot do a base-to-derivedconversion, so that's not the solution here. No, that's exactly what dynamic_cast is for, _if_ the pointer is pointingto an object that actually is of the derived type. >>And a static_cast doesn't seem to make any difference, because i'malready doing static casts right, just in the 'old' way.So i'm still looking for the solution for this situationclass A { public: virtual long GetClassID() { return(' A'); }}; class B { public: // some class data & funx};class C : public class A, public class B { public: virtual long GetClassID() { return(' C'); }}; foo1(C *cp) { ... foo2(cp); ...}foo2(A *ap) { if (ap->GetClassID==' C') { C *cp=(C*)ap; // IS THIS LEGAL and PORTABLE C++ ? }} In theory that would work... of course so would:class A { virtual ~A() {};};class B { virtual ~B() {};};class C : public class A, public class B { virtual ~C() {}; void cfn() {};};foo1(C *cp) { fooA(cp);}fooA(A *ap) { C * cp = dynamic_cast(ap); if (cp != NULL) { cp->cfn(); }} No "getclassid" function required. Indeed. But i prefer not to use RTTI for the reasons mentioned in the earlier post. >However, note that there's no mentionof B anywhere in there (other than the inheritance).... so how does Bget involved in this question? I guess i was confused: Because i ran into the casting problem (due to the use of the void*), i started thinking that it had to do with the multiple inheritance... I really didn't know that using a void* abandons all the class relation info. (and that after all these years of programming, damn damn damn) Thanks a lot for your help! A dummy got a bit less dummy :) Jun 18 '07 #20

 P: n/a On Jun 19, 7:20 am, Jo (ap); Should be a compliation error for the above reason. You can perform the conversion successfully: bp = dynamic_cast(ap); which tells the compiler to find the biggest object that *ap is a sub-object of, and then try to find a B object within that object. This is sometimes called cross-casting. Note, I'm not entirely sure about this, but I think this only works if A and B are both polymorphic classes, that is, they both contain at least one virtual function (which will usually be the virtual destructor). You might just get a null pointer if this requirement is not met. Jun 18 '07 #21

 P: n/a Old Wolf wrote: >On Jun 19, 7:20 am, Jo >If C is derived from A & B, then a C object IS an A and IS a B. At thesame time. Yes, but an A is not a B. The two are unrelatedexcept in that they are both part of a C. Ifyou are pointing to an A, then the only way youare going to be able to point to a related B isif you know you are actually pointing to an Asub-object of a C. Which is why this doesn't workif you are using a pointer to void, which containsno type information. >>// quick recap: class C is derived from both class A and BA *ap;B *bp;C c,*cp;cp=&c;ap=cp;bp=(B*)ap; This is a reinterpret-cast, because A and B are unrelatedtypes (see above). The pointer 'ap' has lost the informationthat it is actually pointing to an A that's a subobjectof a C. >>or the last line beingbp=static_cast(ap); Should be a compliation error for the above reason.You can perform the conversion successfully: bp = dynamic_cast(ap);which tells the compiler to find the biggest objectthat *ap is a sub-object of, and then try to find aB object within that object. This is sometimescalled cross-casting. That's powerful! But at what cost? Do you know how heavy the RTTI overhead is -on memory -on cpu ? If it's similar to using virtual functions, then it's ok. >Note, I'm not entirely sure about this, but I thinkthis only works if A and B are both polymorphicclasses, that is, they both contain at least onevirtual function (which will usually be the virtualdestructor). You might just get a null pointer ifthis requirement is not met. Jun 18 '07 #22

 P: n/a Jo Andre Kostur wrote: >>Jo >No "getclassid" function required. Indeed. But i prefer not to use RTTI for the reasons mentioned in the earlier post. Next item.... measure, measure, measure. How do you know that your own RTTI method is ligher-weight than the one that the compiler is using? >>However, note that there's no mentionof B anywhere in there (other than the inheritance).... so how does Bget involved in this question? I guess i was confused: Because i ran into the casting problem (due to the use of the void*), i started thinking that it had to do with the multiple inheritance... I really didn't know that using a void* abandons all the class relation info. (and that after all these years of programming, damn damn damn) Thanks a lot for your help! A dummy got a bit less dummy :) Ask questions... that's what we're here for :) Jun 18 '07 #23

 P: n/a Andre Kostur wrote: >Jo >Andre Kostur wrote: >>>Jo >>No "getclassid" function required. Indeed.But i prefer not to use RTTI for the reasons mentioned in the earlierpost. Next item.... measure, measure, measure. How do you know that your ownRTTI method is ligher-weight than the one that the compiler is using? True. That's also why i asked about the cost of RTTI. At the moment i don't have a clue. >>>However, note that there's no mentionof B anywhere in there (other than the inheritance).... so how does Bget involved in this question? I guess i was confused:Because i ran into the casting problem (due to the use of the void*),i started thinking that it had to do with the multiple inheritance...I really didn't know that using a void* abandons all the classrelation info. (and that after all these years of programming, damndamn damn)Thanks a lot for your help!A dummy got a bit less dummy :) Ask questions... that's what we're here for :) Jun 18 '07 #24

 P: n/a Jo wrote: Andre Kostur wrote: >Jo >But i prefer not to use RTTI for the reasons mentioned in the earlierpost. Next item.... measure, measure, measure. How do you know that yourown RTTI method is ligher-weight than the one that the compiler isusing? True. That's also why i asked about the cost of RTTI. At the moment i don't have a clue. Well, i've been experimenting a bit with dynamic_cast and must say it's a nice feature. Why is it that i read al these warnings about RTTI, not only about the overhead, but also about "it's better not to use it". Didn't find some explicit reasoning yet. Jun 18 '07 #25

 P: n/a Jo wrote: Jo wrote: >Andre Kostur wrote: >>Jo Didn't find some explicit reasoning yet. Jun 18 '07 #26

 P: n/a Jo Jo wrote: >>Andre Kostur wrote:Jo

 P: n/a On Jun 18, 6:17 pm, Jo

 P: n/a Andre Kostur wrote: >Jo >Jo wrote: >>>Jo wrote: Andre Kostur wrote: >Jo >>>>But i prefer not to use RTTI for the reasons mentioned in the>>earlier post.>>>>>>Next item.... measure, measure, measure. How do you know that your>own RTTI method is ligher-weight than the one that the compiler is>using?>>True.That's also why i asked about the cost of RTTI.At the moment i don't have a clue. Well, i've been experimenting a bit with dynamic_cast and must sayit's a nice feature.Why is it that i read al these warnings about RTTI, not only aboutthe overhead, but also about "it's better not to use it". I'm sorry, must be more precise: the warnings i read is more like"better not to use it, unless really necessary". Performance-wise there is a certain cost to using it, but I don't thinkit would be any heavier than attempting to implement your own. I thinkthis is really a QoI (Quality of Implementation) issue with whatevercompiler you're using.However, a necessity to using dynamic_cast