Re: Problem with multiple inheritance
In article news:<go14f3$h38$1@aioe.org>, No_Name wrote:
I have a class named A.
I have a class named AB which inherits from A.
I have a class named C.
Class C has a function I_Am_From_C().
I have a class named ABC which inherits from AB and from C.
Class AB has a function InheritsFromC() which gives false;
Class ABC has a function InheritsFromC() which gives true;
... and you want to be able to handle your AB and ABC objects
polymorphically through A* pointers. The problem is that you have to
cast them back to AB or ABC to use them, and you don't know which they
are.
As others have already said, you can use C++ RTTI to achieve this.
As we're in microsoft.public.vc.mfc I should also mention that MFC
doesn't use the built-in RTTI provided by C++ (because Microsoft's
16-bit C++ compiler didn't support RTTI, so an alternative mechanism
was written into MFC and was kept for compatibility). If your objects
are all derived from CObject you might prefer to use that mechanism
rather than enabling RTTI for your project (RTTI does impose a small
overhead).
You weren't far wrong with your own attempt, though. It would have
worked if you'd done the casting differently:
void MyFunction(A *myObject)
{
// here myObject is a pointer of type A* that actually
// points to either an AB or an ABC
if( myObject->InheritsFromC() )
{
// Now we know that myObject is actually an ABC*
ABC* pObj = dynamic_cast<ABC*>(myObject);
pObj->I_Am_From_C();
}
else
{
// here myObject is actually an AB*
}
}
This is not quite as simple as the RTTI example given by others, but it
works even with RTTI not enabled. It's your choice.
Important points to note are:
1. Cast to ABC* not to C*. If you really want a C* pointer you must
cast first to ABC* then cast a second time to C*.
2. Use a C++ dynamic cast here because you are using the cast to get a
pointer to a related class within the class hierarchy. ABC is related
to A (but C is not) so a dynamic cast will work -- the compiler will
give an error if you try to dynamic_cast between things that are not
related.
Do not use a reinterpret_cast because that tells the compiler to
"reinterpret" the data representing one type as though it actually
represented another.
A C style cast will have the same effect as a dynamic_cast if you
specify the types correctly, and so will work, but if you get the types
wrong (as you did) it will act as a reinterpret_cast without the
compiler giving any warning. Avoid the C style cast.
Cheers,
Daniel.