为具有多重继承的一种类型设置默认构造函数

Question

我有两个班级，Base 和 Derived。 Derived 继承了 Base 的所有构造函数。另外，我有一个模板类Printer<T>，它包含对T 类型对象的引用，并有一个方法print()，它以某种方式打印一个对象。这是一个最小的插图。

class Base {
public:
    Base(int x) : x(x) {}
    int x;
};

template<typename T>
class Printer {
public:
    const T& object;

    Printer(const T& object) : object(object) {}

    void print() {
        cout << object << endl;
    }
};

class Derived : public Base {
public:
    using Base::Base;
};

std::ostream& operator<<(std::ostream& out, const Derived& d) {
    return out << d.x;
}

int main() {
    Derived d(1);

    Printer<Derived>(d).print();
}

现在我想避免直接使用Printer 并允许这样的语法：Derived d(1); d.print();。因此我尝试从Printer<Derived> 继承Derived。

class Derived : public Base, public Printer<Derived> {
public:
    typedef Printer<Derived> MyPrinter;

    using Base::Base;

    Derived() : MyPrinter(*this) {}
};  

现在我有一个问题：Base 构造函数对Printer 一无所知，因此无法以任何方式对其进行初始化。我也不能在这里使用构造函数委托，因为Derived 中使用的构造函数实际上是从Base 继承的。

我能否以某种方式使Derived 的默认构造函数由任何其他构造函数委托，甚至是继承的构造函数？或者也许还有其他一些模式来初始化多重继承中的第二个基？

还有一件事使一切变得更加困难，那就是我无法访问Base 的代码，只能按原样使用它。

更新 在 Remy Lebeau 的回答中：Base 可以有多个我不知道的构造函数（它也是一个模板类），所以我无法实现所有这些，必须使用 using Base::Base 成语。

关于 krzaq 的回答：Printer 其实也有很多方法，不仅仅是print()，所以实现转发器类是一件麻烦事，我尽量避免。

Answer 1

如果您只需要从Printer<Derived> 访问Derived 实例，那么您可以简单地将其强制转换：

template<typename T>
class Printer {
public:
    const T& object;

    Printer() : object(static_cast<T&>(*this)) {}

    void print() {
        cout << object << endl;
    }
};

live demo

或完全取消参考，让您的班级有资格获得EBO：

template<typename T>
class Printer {
public:
    void print() {
        cout << static_cast<T&>(*this) << endl;
    }
};

live demo

如果您也不能/不想触摸 Printer，我会创建一个单独的模板 PrinterForwarder 以将 print() 调用发送到正确的打印机：

template<typename T>
class PrinterForwarder
{
public:
    void print() {
        Printer<T>(static_cast<T&>(*this)).print();
    }
};

class Derived : public Base, public PrinterForwarder<Derived> {
public:
    using Base::Base;
};

live demo

Answer 2

现在我有一个问题：基础构造函数对打印机一无所知，因此无法以任何方式对其进行初始化。

要执行您正在尝试的操作，您将无法再使用using Base::Base 语句。您必须更明确地了解Derived 实现的构造函数，以便它们可以根据需要分别初始化Printer 基类，例如：

class Derived : public Base, public Printer<Derived> {
public:
    typedef Printer<Derived> MyPrinter;

    Derived() : Base(0), MyPrinter(*this) {}
    Derived(int x) : Base(x), MyPrinter(*this) {}
};  

或者：

class Derived : public Base, public Printer<Derived> {
public:
    typedef Printer<Derived> MyPrinter;

    Derived() : Derived(0) {}
    Derived(int x) : Base(x), MyPrinter(*this) {}
};  

Answer 3

您可以创建一个可变参数模板包罗万象的构造函数，它将参数传递给 Base 并根据需要构造 Printer，像这样

class Derived: ... {
   template<typename... Args>
   Derived(Args&&... args): Base(std::forward<Args>(args)...), Printer(*this) {}
}

Answer 4

我找到了一个非常简单的解决方案。让我们在 Printer 中存储指向 T 的指针，而不是引用。

template<typename T>
class Printer {
public:
    const T* objectPtr;

    Printer() : objectPtr(nullptr) {}
    Printer(const T& object) : objectPtr(&object) {}

    void print() {
        if (objectPtr) {
            cout << *objectPtr << endl;
        } else {
            cout << static_cast<const T&>(*this) << endl;
        }
    }
};

看起来不太安全，但将 Printer() ctor 设为私有似乎可以达成交易。