如何避免使用虚拟继承调用过多的参数化构造函数？

Question

我想通过以下明显的示例执行虚拟继承：

class A
{
public:
    A(int a) : m_a(a) {}
private:
    int m_a;
};

class B : virtual public A
{
public:
    B(int a, int b) : A(a), m_b(b) {}
private:
    int m_b;
};

class C : virtual public A
{
public:
    C(int a, int c) : A(a), m_c(c) {}
private:
    int m_c;
};

class D : public B, public C
{
public:
    D(int a, int b, int c) : A(a), B(a, b), C(a, c) {}
};

但我不想调用 B(a, b) 和 C(a, c)，因为对于这种虚拟继承的特殊情况，参数 a 在 B 和 C 构造函数中是无用的。

我发现以下文章 Jack Reeves 提出了一些替代方案以调用默认构造函数。

http://www.drdobbs.com/cpp/multiple-inheritance-considered-useful/184402074?pgno=2

引用：

如果我们必须在构造 B 和 C 之前完全初始化 A，那么我们必须使用构造函数进行初始化，我们回到我最初展示的内容。或者，也许您可​​以通过以下方式解决：

class B : public virtual A {  // class C is similar
public:
    B(int x) : A(x) {}
protected:
    B() : A(0) {}
};
class D : public B, public C {
public:
    D(int x) : A(x) {}  // B and C are default constructed
};

引用结束。

所以，我保留了受保护构造函数的想法，但我不想使用默认构造函数。我在 A 中实现了一个单参数构造函数（在实践中从未调用过），它使用前向构造函数指向类内“最简单”的有效构造函数（保持 B 和 C 应该在 A 中调用的内容的封装）。这里的单个参数是为了给这个“混蛋”构造函数一个唯一的签名。

// new way
namespace VIRTUAL_INHERITANCE {
struct NEVER_CALLED {};
}

class A
{
public:
    A(int a) : m_a(a) {}
protected:
    A(VIRTUAL_INHERITANCE::NEVER_CALLED vinc) : A(0) {}
private:
    int m_a;
};

class B : virtual public A
{
public:
    B(int a, int b) : A(a), m_b(b) {}
protected:
    B(int b) : A(VIRTUAL_INHERITANCE::NEVER_CALLED()), m_b(b) {}
private:
    int m_b;
};

class C : virtual public A
{
public:
    C(int a, int c) : A(a), m_c(c) {}
protected:
    C(int c) : A(VIRTUAL_INHERITANCE::NEVER_CALLED()), m_c(c) {}
private:
    int m_c;
};

class D : public B, public C
{
public:
    D(int a, int b, int c) : A(a), B(b), C(c) {}
};

我的问题是：

• 如何避免使用虚拟继承调用过多参数化的构造函数？

• 是否可以通过其他方式改进“唯一签名”技术（例如使用枚举）？

• 有没有人有更好的技术来做同样的事情而不必在 A 中定义第二个构造函数？

• 有什么缺点？

Answer 1

我的答案是：

• 使用默认构造函数，
• 是的，enum 可以，
• 没有。如果您希望编译器强制您显式调用A 的构造函数，那么您必须声明附加构造函数。但是，如果您不...使用默认构造函数和 init 函数或只是一个常规的参数化构造函数，
• 具有“唯一签名”构造函数的缺点：
  • A 类中的更多代码，
  • 更多代码在B类中，
  • 更多代码在C类中，
  • 由于虚拟结构导致更多代码。
• 使用带有“init”函数的默认 c-tor 的缺点：
  • 一定要记得调用init函数或参数化构造函数

示例（整洁的）代码：

class A
{
public:
    A(int a) : m_a(a) {}
protected:
    A() = default;
    void initA(int a) { m_a = a; } // optional
private:
    int m_a;
};

class B : virtual public A
{
public:
    B(int a, int b) : A(a), m_b(b) {}
protected:
    B(int b) : m_b(b) {}
private:
    int m_b;
};

class C : virtual public A
{
public:
    C(int a, int c) : A(a), m_c(c) {}
protected:
    C(int c) : m_c(c) {}
private:
    int m_c;
};

class D : public B, public C
{
public:
    D(int a, int b, int c) : A(a), B(b), C(c) {}
    // or optionally:
    D(int a, int b, int c) : B(b), C(c) { initA(a); }
};