Question

Suppose there is this interface:

class A{  
 public:  
  virtual foo()=0;  
};

And a class B which implements this interface:

class B:public A{    
 public:   
  virtual foo(){} //Foo implemented by B   
}

Finally, a class C which has classes A and B as base classes:

Class C : public A, public B {
};

My question is, there is a way to tell the compiler that the implementation for foo is the one from class B without doing an explicit call to B::foo()?

Answer 1

As @BenVoigt pointed out in the comments, the below answer only works due to a bug in g++ (meaning it isn’t guaranteed to keep working, and it definitely isn’t portable). Thus, although it may do what you want if you use a particular (buggy) compiler, it isn’t an option you should use.

Do use virtual inheritance though.

---

This isn’t exactly the scenario that the code in the question implies, but the sentence

My question is, there is a way to tell the compiler that the
implementation for foo is the one from class B without doing an
explicit call to B::foo()?

seems to be asking for syntax to distinguish between multiple base versions of a function without using the :: qualifier.

You can do this with the using directive:

#include <iostream>
class A {
public:
A(){}
virtual void foo(){std::cout<<"A func";}
};

class B: virtual public A {
  public:
  B(){}
  virtual void foo(){std::cout<<"B func";}
};
class C:virtual public A, virtual public B {
    public:
    C(){}
    using A::foo; // tells the compiler which version to use
                   // could also say using B::foo, though this is unnecessary
};

int main() {
    C c;
    c.foo(); // prints "A func"
    return 0;
}

Of course, the code itself in the question doesn’t require this at all, as the other answers have pointed out.