Question

假设有这个界面：

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

实现此接口的类B：

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

最后，类C以类A和B作为基类：

Class C : public A, public B {
};

我的问题是，有一种方法可以告诉编译器foo的实现是来自B类的实现，而没有显式调用B::foo()？

Answer 1

正如@BenVoigt在评论中所指出的，以下答案仅适用于g ++中的错误（意味着它不能保证继续工作，并且它绝对不可移植）。因此，虽然如果你使用特定的（错误的）编译器它可能会做你想要的，但它不是你应该使用的选项。

虽然使用virtual inheritance。

这不是问题中代码所暗示的情景，而是句子

我的问题是，有一种方法可以告诉编译器 foo的实现是来自B类的没有做的显式调用B :: foo（）？

似乎要求语法在不使用::限定符的情况下区分函数的多个基本版本。

您可以使用using指令执行此操作：

#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;
}

当然，正如其他答案所指出的那样，问题中的代码本身并不需要这样做。

Answer 2

只需使用虚拟继承，以便A提供的B子对象与C中使用的对象相同。

或者写class C : public B ...无论如何，它将通过基类A隐式地用作B。

在编辑问题之前：

B::foo与A::foo不兼容。

所需的签名是

ReturnType /* missing from question */ foo(A* const this /* this parameter is implicit */);

但B::foo有签名

ReturnType foo(B* const this);

将传递给虚函数的A*不是实现所需的B*。如果B继承自A，则编译器将生成B::foo以接受A* const subobject并从该子对象指针中找到B* const this对象。但是B::foo C并不了解这种关系。

Answer 3

由于您的示例中有两个基类（可能是设计问题/设计气味，我会对此进行审核），您必须明确调用您正在执行的实现，不管是{{1} }或A::foo()。

如果所有B都提供B:foo()的实现，我会考虑将实现转移到A（您可以为纯虚函数提供实现），但即使在这种情况下，您也可以d必须通过其合格的名称来调用它。

实现具有多重继承的纯虚函数

3 个答案: