C++ virtual override functions with same name

Question

I have something like that (simplified)

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

class B
{
  public:
    virtual void Function () = 0;
};

class Impl : public A , public B
{
  public:
        ????
};

How can I implement the Function () for A and the Function() for B ? Visual C++ lets you only define the specific function inline (i.e. not in the cpp file), but I suppose it's an extension. GCC complains about this. Is there a standard C++ way to tell the compiler which function I want to override?

(visual c++ 2008)

class Impl : public A , public B
{
  public:
     void A::Function () {  cout << "A::Function" << endl; }
     void B::Function () {  cout << "B::Function" << endl; }
};

Thank you!

Answer 1

You cannot use qualified names there. I you write void Function() { ... } you are overriding both functions. Herb Sutter shows how it can be solved.

Another option is to rename those functions, because apparently they do something different (otherwise i don't see the problem of overriding both with identical behavior).

Answer 2

As a workaround, try

struct Impl_A : A
{ 
     void Function () {  cout << "A::Function" << endl; } 
}; 


struct Impl_B : B
{
    void Function () { cout << "B::function" << endl; }
};

struct Impl : Impl_A, Impl_B {};

Answer 3

I can suggest another way to resolve this issue. You can add wrapper Typed which changes Function signature by adding dummy parameter. Thus you can distinguish methods in your implementation.

class A {
public:
  virtual void Function() = 0;
  virtual ~A() = default;
};

class B {
public:
  virtual void Function() = 0;
  virtual ~B() = default;
};

template<typename T>
class Typed : public T {
public:
  virtual void Function(T* dummy) = 0;
  void Function() override {
    Function(nullptr);
  }
};

class Impl : public Typed<A>, public Typed<B> {
public:
  void Function(A* dummy) override {
    std::cerr << "implements A::Function()" << std::endl;
  }
  void Function(B* dummy) override {
    std::cerr << "implements B::Function()" << std::endl;
  }
};

The benefit of such solution is that all implementation are placed in one class.

Answer 4

If A and B are interfaces, then I would use virtual derivation to "join" them (make them overlap). If you need different implementations for your Function if called through a pointer to A or to B then I would strongly recommend to choose another design. That will hurt otherwise.

Impl "derives from" A and B means Impl "is a" A and B. I suppose you do not mean it.

Impl "implements interface" A and B means Impl "behaves like" A and B. then same interface should mean the same behavior.

In both cases having a different behavior according to the type of pointer used would be "schizophrenic" and is for sure a situation to avoid.