我在尝试重用来自不同类的代码时偶然发现了一个问题。我把它贴在这里，希望你们中的一些人能够帮助我。
我有一组类 (B,C) 派生自同一个类 (A)，它强制执行某些方法 (foo, run)。 B类实现了这些方法，B类和C类都提供了其他方法:
#include<iostream>
template<class I, class O>
class A {
public:
A() {}
virtual ~A() {}
virtual void foo() const = 0; // force implementation of this function
virtual void run() const = 0; // force implementation of this function
};
template<class I, class O>
class B : public A<I,O> {
public:
B() {}
virtual ~B() {}
virtual void foo() const { // implementation for the Base class
std::cout << "B's implementation of foo" << std::endl;
}
virtual void run() const { // implementation for the Base class
std::cout << "B's implementation of run" << std::endl;
}
virtual void foobar() const { // some other function provided by this class
std::cout << "B's implementation of foobar" << std::endl;
}
};
template<class I, class O, class M>
class C : public A<I,O> {
public:
C() {}
virtual ~C() {}
virtual void bar(M m) const { // some other function provided by this class
std::cout << "C's implementation of bar with: " << m << std::endl;
}
};
现在，我要做的是同时继承 B 和 C，这样我就可以拥有额外的方法(foobar、bar)，但也不必实现类 A (foo) 的方法，因为它已经B 中定义:
template<class I, class O>
class D : public B<I,O>, public C<I,O,int> {
public:
D() {}
void run() const {
this->bar(123);
this->foo();
this->foobar();
}
};
但出于某种原因，编译器给我这个错误:
test.cpp: In function ‘int main(int, char**)’:
test.cpp:68:35: error: cannot allocate an object of abstract type ‘D<float, double>’
A<float, double> *d = new D<float, double>(); // what I need to do
test.cpp:48:11: 注意:因为以下虚函数在‘D’中是纯的:
class D : public B<I,O>, public C<I,O,int> {
^
test.cpp:9:22: 注意:void A::foo() const [with I = float; O = 双]
virtual void foo() const = 0; // force implementation of this function
这是我用来运行它的代码:
int main(int argc, char **argv)
{
A<float, double> *b = new B<float, double>();
b->foo(); // prints "B's implementation of foo"
b->run(); // prints "B's implementation of run"
//A<float, double> *c = new C<float, double, int>(); // obviously fails because C does not implement any of A's functions
//A<float, double> *d = new D<float, double>; // line 68: what I need to do
//d->run(); // ***throws the abstract class error
return 0;
}
我想从指向 A 的指针使用 D 类对象的“运行”函数。由于所有函数都是虚拟的，我希望执行在最低继承点中定义的每个函数的实现，这意味着“B”::run' 将被丢弃。由于“D::run”同时使用 B 和 C 中的函数，因此我需要从这两个类继承。
我希望我已经对它进行了足够的描述，没有让任何人感到困惑。
感谢您的帮助!
如果你改变B和 C几乎继承自 A模板类，当通过 D 组合时，它们将共享一个基实例并且此错误将消失:
template<class I, class O>
class B : virtual public A<I,O> {
// ...
template<class I, class O, class M>
class C : virtual public A<I,O> {
但是，这种模式(称为菱形继承(反)模式)可能很难推理，我强烈建议尽可能避免使用它。以后您可能会遇到更晦涩的问题。
下面是该技术的一个示例，但显示的结果乍一看可能出乎意料:
class A {
public:
virtual void foo() = 0;
};
class B : virtual public A {
public:
virtual void foo() override;
};
void B::foo()
{
std::cout << "B::foo()" << std::endl;
}
class C : virtual public A { };
class D : public B, public C { };
int main() {
D d;
C & c = d;
c.foo();
return 0;
}
请注意，即使您正在调用 C::foo() , 这是纯虚拟的，因为只有一个 A实例继承的纯虚函数解析为B::foo()虽然共享 A虚表。这是一个有点令人惊讶的副作用——您最终可以调用在表亲类型上实现的方法。
