C++如何初始化抽象基类引用元素？

Question

我的问题是基于典型的菱形层次结构，但不是典型的菱形问题。

class Interface
{
public:
    int value; 
    // SomeBigData &data; 
    Interface(int _value = 0) : value(_value) {}; 

    virtual void function1() = 0; 
    virtual void function2() = 0; 
};

class ImpOne : public virtual Interface
{
public:
    void function1() { ++value; }
};

class ImpTwo : public virtual Interface
{
public:
    void function2() { --value; }
};

class Device : public ImpOne, public ImpTwo
{
public:
    Device() : Interface(7) {}; 
};

有一个抽象接口定义了许多功能（上面的例子是简化的）。然后有一些实现类一次只实现其中的几个功能。最后，还有一个非抽象类，如上面的 Device 类，通过将几个实现类组合在一起来实现整个接口。

现在，问题是这样的：

Interface 类中有一个整数元素，它由 Device 类初始化并在实现类之间共享，到目前为止一切都很好。但是如果我从Interface(int _value = 0) 构造函数中删除= 0，整个系统就会崩溃，因为我缺少接口类的默认构造函数，这有点奇怪，因为它永远不会被调用。

为什么这会困扰我？正如代码中所建议的，接口类需要包含对复杂数据结构（不属于该类）的引用，而不是在所有派生实现类之间共享。然而，为引用指定默认值既不明智也不可能。

所以问题是：

如何正确初始化接口类（引用）元素，例如代码中建议的SomeBigData &data，我无法为默认构造函数指定默认值（无论如何都不会调用）？还是我做错了什么？

Answer 1

你可以这样做：

class Interface {
public:
    int value; 
    virtual SomeBigData& getBigData() = 0;
    Interface(int _value = 0) : value(_value) {}; 

    virtual void function1() = 0; 
    virtual void function2() = 0; 
};

class BigDataProvider : public virtual Interface {
public:
    SomeBigData& data_;
    BigDataProvider(SomeBigData& data) : data_(data) {}
    SomeBigData& getBigData() { return data_; }
};

class Device : public BigDataProvider, public ImpOne, public ImpTwo {
public:
    Device(SomeBigData& data) : BigDataProvider(data), Interface(7) {}
};

您的成员value 也可以使用相同的模式。那么Interface 将是一个“纯界面”，您可以避免整体上的菱形类布局。

Answer 2

你可以声明一个没有实现的默认构造函数：(https://ideone.com/ZD336z)

class Interface
{
public:
    Interface(int _value, SomeBigData &data) : value(_value), data(data) {}
    ~Interface() {}

    virtual void function1() = 0;
    virtual void function2() = 0;
protected:
    Interface(); // No implementation
protected:
    int value;
    SomeBigData &data;
};

该方法应该对派生类可见，但不需要实现，因为只调用了另一个构造函数。

Answer 3

莫恩，

首先，我认为您还必须为ImpOne 和ImpTwo 声明一个构造函数。否则，他们会在构建时尝试调用Interface()，而这并不存在。 其次，你可以使用Composite Pattern来避免钻石问题。

class Interface                         // abstract
{
protected:
    Base() {}

public:
    virtual void f1(int &value) {}
    virtual void f2(int &value) {}
}

class ImpOne: Base                    
{
public:
    void f1(int &value) { value++; }
}

class ImpTwo : Base                    
{
public:
    void f2(int &value) { value--; }
}

class DeviceBase                        // abstract base for all "Devices"
{
protected:
    int value;
    List<Interface*> Leaves;            // use std::vector or whatever dependent 
                                        // on your library
    Composite(int val) { value = val; }

public:
    void f1()
    {
        for (Interface* const leaf : Leaves)
            leaf->f1(value);
    }

    void f2()
    {
        for (Interface* const leaf : Leaves)
            leaf->f2(value);
    }
}

class Device : DeviceBase
{
public:
    Device(int val) : DeviceBase(val)
    {
        Leaves << new ImpOne(value);
        Leaves << new ImpTwo(value);
    }
}    

Greez Albjeno