多重继承中的歧义

Question

Let's say i have this simple code

#include <iostream>
using namespace std;

class A {
 public:
    void show() {
        cout << "A" << endl;
    }
};

class B {
 public:
    void show() {
        cout << "B" << endl;
    }
};

class C:public A, public B {
};

int main()
{
    C obj;
    obj.show();
}

this throws a compile time error because the call to function show() is ambiguous. I want to know how does the compiler understand this? Object creation is a run time process, so, how does the compiler know before hand that an object of Class C is going to be created which would invoke show(). Can anybody please tell me the concept behind this?

Answer 1

You are inheriting both the base classes A and B which has the same method show in C . This is the reason you are facing the compiler error ambiguous access of 'show' .

To get over it, you need to be more explicit on which `show method you would want to invoke. It would be easy to do it using the scope resolution operator.

• To invoke show method of A : obj.A::show() ;
• To invoke show method of B : obj.B::show() ;

Answer 2

This concept is called "Late Binding" in "Polymorphism". It means, the code tells the compiler to understand what to do on runtime. You should use virtual functions in this manner; and it is only available when you use this with "pointers". Let me give you a little example.

class Teacher {                          //base class
    string name;
    int numOfStudents;
public:
    Teacher( const string &, int );      // constructor of base
    virtual void print() const;          // a virtual (polymorphic) function
};
class Principal : public Teacher{        // derived class
    string SchoolName;
public:
    Principal( const string &, int , const string & );
    void print() const;                  // also virtual (polymorphic)
};

If you create a Principal object on main function and then call its print() function, compiler will run the function which is defined in "Principal" class. But if you don't define a print() function in a class which you derived from "Teacher" class, then when you call a print() function of that class' object pointer it will run the print() defined in "Teacher" class.

But again do not try this with the object itself, you should do it with pointers.

Best regards.

Answer 3

Here is the answer you are looking for: obj is of type C which means it is both type A and type B. I am trying to be careful not to say "has-a" when it is "is-a", but, in my mind, an object of type C has also an object of type A and type B. When you call a constructor for type C, you would also call the constructors of type A and B. So, up to the point of creation of obj, everything is fine. But, after that the compiler has to decide which of the two show()'s to call. And that is when it is getting confused.

Answer 4

You are inheriting from both the classes A and B. That's why it is showing you an error, namely because it is ambiguous. To handle this you can refer explicitly to the function or method should be invoked at the time of calling by the object of the C's object. This way the compiler doesn't get confused and doesn't show any error to you. CODE :

class A{
   public: 
     void show(){ cout<<"Class A"; }
};
class B{
   public:
      void show(){  cout<<"Class B";  }
};
class C : public A , public B{
   public:
      void disp(){  A::show(); } // Here You can make explicit from which class the method
                               //  shall be called. I refer to method "show" from class A.
}
main(){
  C obj;
  obj.disp(); // Ambiguity in Multiple Inheritance Problem Solved

}