Re: multiple inheritance confusion
On Sep 18, 1:34 pm, zero <z...@this.hi> wrote:
Hi all,
given the following code:
#include <iostream>
struct Abstract {
virtual void HandleIt() = 0;
virtual void Handle( int ) = 0;
virtual ~Abstract() {}
};
struct A : Abstract {
virtual void HandleIt() {
std::cout << "A::Handle()" << std::endl;
Handle( 1 );
}
virtual void Handle( int ) {
std::cout << "A::Handle( int )" << std::endl;
}
};
struct B : Abstract {
virtual void HandleIt() {
std::cout << "B::Handle()" << std::endl;
Handle( 1 );
}
virtual void Handle( int ) {
std::cout << "B::Handle( int )" << std::endl;
}
};
struct C : A, B {
virtual void HandleIt() {
std::cout << "C::Handle()" << std::endl;
B::HandleIt();
}
};
int main() {
C theC;
theC.HandleIt();
}
Why doesn't theD.HandleIt() cause an ambiguity error? With the compilers
I tested (gcc 4 and Borland C++ 5.82), B::Handle( 1 ) was called. Since
this call is virtual and the dynamic type of the object is C, I expected
a compiler error, just like when typing theC.Handle( 1 );
Could someone point me to the part of the spec that talks about this - or
is this simply an implementation defined coincidence?
Let's walk through what happens here:
theC.HandleIt();
The static type (and dynamic type) is C. virtual lookup does not apply
in this case; we're not using a pointer or a reference. It will call
C::HandleIt(). C::HandleIt() looks like:
std::cout << "C::Handle()" << std::endl;
B::HandleIt();
Now, it will print C::Handle() and then call B::HandleIt(), which
looks like:
std::cout << "B::Handle()" << std::endl;
Handle( 1 );
Now, there is an implicit this-> in front of any member function call.
This call is through a pointer, and thus it uses virtual lookup. Now,
this call is done from the perspective of a B pointer, not a C
pointer, and that is the distinction. The dynamic type of the object
is C, but the "this" pointer is a B pointer. It will look at the
inheritance chains from all of the base classes of B to B, and B to
the dynamic type. Of all of the virtual functions implementations in
these chains, it will pick the one of the most derived class (which
may lead to an ambiguous call, determinable at compile time).
In this case, there is no ambiguity. The "most-derived" implementation
is B's.
Put another way, B does not inherit from A (directly or indirectly),
and A does not inherit from B (directly or indirectly), thus virtual
lookups using a B pointer do not care about A.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]