虚拟继承：接口和构造函数

Question

我正在使用 C++11。我试图声明 2 个接口：B 和 C，每个接口声明一些由子类实现的函数。这两个接口都依赖于公共 A 类中声明的变量和函数。即使这种相对简单的结构也会导致钻石继承问题。(https: //www.makeuseof.com/what-is-diamond-problem-in-cpp/） 我使用虚拟继承来链接 A 和 B/C，尝试实现如下所示的内容：

#edit 1 将原始代码片段修改为最小的可重现示例。

class T1{};
class A{
public:
    A(const T1& param1);

    void myfuna();
    const T1 member1;
};
class B : public virtual A{
    virtual void myfunb()=0;
};
class C: public virtual A{
    virtual void myfunc()=0;
};
class Di: public B, public C{
    Di(const T1& param1): A(param1){}
    void myfunb() override;
    void myfunc() override;
};

但是，这段代码无法编译。原因是 cpp 接口并不完全是“接口”（我有 Java 背景），因为即使使用虚拟继承，它们仍然有一个被调用的默认构造函数。这意味着在初始化“D”实例时，将调用这些构造函数：

• A(param1,param2)
• B()
• C()

B 和 C 构造函数依次尝试调用 A() 构造函数，这是错误的 -定义（我收到“调用隐式删除默认构造函数”错误）。罪魁祸首是 A 的 const 字段，它禁用了默认构造函数。

我找不到一种优雅的方法来解决这个问题。我是否遗漏了一些东西，我的设计是否有缺陷，或者这只是 cpp 的限制？

Answer 1

解决方案是：

• 创建B和C抽象类。
• 或者为 A 定义一个默认构造函数。
• 或者在B和C的构造函数中调用A的非默认构造函数。

Answer 2

正如 @eerorika 所说，有 2 个选项可以解决这个问题：

为 A() 定义默认构造函数

使用虚拟参数实例化父类相对容易，因此默认构造函数是定义的。它有点难看，但因为默认构造函数创建的对象通常永远不会被使用，所以它应该可以工作。

我还有一句话：想象一下类B实现了他的一个函数（参见“implementeB”）并且需要访问member1。将访问什么对象？虚拟变量还是赋予 Di 构造函数的变量（param1）？ 如果使用哑变量，这是一个问题。

class T1{};
static const T1 dummy;

class A{
public:
    A(): member1(dummy){}
    A(const T1& param1);
    void myfuna();
    const T1 member1;
};

class B : public virtual A{
public:
    virtual void myfunb()=0;
    T1 implementedB(){
        return member1;
    }
};

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

class Di: public B,
        public C
{
public:
    Di(const T1& param1):
    A(param1){}
    void myfunb() override{}
    void myfunc() override{}
};

在B和C的构造函数中调用A的非默认构造函数。
我相信这是正确的解决方案。然而，这也意味着 A 的参数列表需要传播到所有子类。对于更大的类，这可能会很快变得很大，并且它有点违背了“接口”的目的。这也意味着子类（“Di”）需要显式调用所有基类构造函数（A（..），B（..）和C（..））我想没有一个理想的方法.. 。

class T1{};
static const T1 dummy;

class A{
public:
    A(const T1& param1);

    void myfuna();
    const T1 member1;
};

class B : public virtual A{
public:
    B(T1 param1) : A(param1){}
    virtual void myfunb()=0;
};

class C: public virtual A{
public:
    C(T1 param1) : A(param1){}
    virtual void myfunc()=0;
};

class Di: public B,
        public C
{
public:
    Di(const T1& param1):
    A(param1), B(param1), C(param1){

    }
    void myfunb() override{}
    void myfunc() override{}
};