指向组合接口的指针 - 指向实现一个接口并从另一个实现扩展的类

Question

我有两个接口：

class FirstInterface
{
    virtual int getId() const = 0;
};

class SecondInterface
{
    virtual void setId(int id) = 0;
};

这是一个组合界面：

class CombinedInterface : public FirstInterface, public SecondInterface
{

};

这是第一个接口的具体类：

class FirstConcrete : public FirstInterface
{
    virtual int getId() const
    {
        return 1;
    }
};

现在，这个类 CompleteConcrete 应该有 CombinedInterface 但想同时重用 FirstConcrete 的实现。

class CompleteConcrete : public FirstConcrete, public SecondInterface
{
    virtual void setId(int id) { }
};

// This is wrong C++
// Cannot convert from CompleteConcrete * to CombinedInterface *
// CombinedInterface * combinedInterface = new CompleteConcrete();

这当然行不通。 有谁知道用 C++ 实现这个目标的方法吗？

Answer 1

这是我在 cmets 中提到的基于虚拟继承的解决方案：

class FirstInterface
{
    virtual int getId() const = 0;
};

class SecondInterface
{
    virtual void setId(int id) = 0;
};


class CombinedInterface : virtual public FirstInterface,
              virtual public SecondInterface
{

};

class FirstConcrete : virtual public FirstInterface
{
    virtual int getId() const
    {
        return 1;
    }
};

class CompleteConcrete : virtual public FirstConcrete,
             virtual public CombinedInterface
{
    virtual void setId(int id) { }
};

void example()
{
    CombinedInterface * combinedInterface = new CompleteConcrete();
}

使用虚拟继承，唯一需要的更改（除了房间里的大象）是从CombinedInterface 获得CompleteConcrete multiply-inherit，而不是SecondInterface。你可以这样想：图中有CompleteConcreate，现在支持CombinedInterface，而不仅仅是增加了SecondInterface。

有些人不赞成虚拟继承。我不。这是 C++ 的独特功能之一，没有其他高级语言共享，TMK。它是一个非常强大的工具，可以解决某些其他方式难以解决的问题。虚拟继承的两个主要缺点是：

1. 因为功能强大，很容易被误用，导致各种问题。

2. 如果虚拟继承的类有非默认构造函数，它很快就会变得很痛苦，因为现在每个虚拟继承某些东西的类都负责构造它。

但只要正确使用虚拟继承，并且所涉及的类可以自行构建，虚拟继承是一个有用的工具。

附：我还将提到刚刚想到的另一种替代解决方案。如果说你有你的CombinedInterface 只是为了某些特定功能需要它，比如：

 void somefunction(CombinedInterface &object);

您的函数需要一个组合接口。

做一个小改动：

 void somefunction(FirstInterface &first, SecondInterface &second);

并传递相同的对象作为两个参数。您可以传递实现这两个接口的CompleteConcrete，而无需对您的类层次结构进行任何更改。你也可以有一个模板外观，让它看起来像函数仍然需要一个参数：

template<typename T> void somefunction(T &&t)
{
    real_somefunction(std::forward<T>(t), std::forward<T>(t));
}

void real_somefunction(FirstInterface &first, SecondInterface &second);

您几乎可以摆脱CombinedInterface，只需将实现这两​​个接口的任何对象传递给somefunction()，您的real_somefunction() 将使用一个或另一个参数来调用适当的接口。

假设您需要携带一个指向实现这两个接口的对象的指针？

class combined_pointer : public std::pair<FirstInterface *, SecondInterface *> {

public:
    template<typename T> combined_pointer(T *t)
            : std::pair<FirstInterface *, SecondInterface *>(t, t)
    {}
};

只是一个起点。

Answer 2

我使用过虚拟继承。

这个编译成功，但有警告，但我认为没问题。

class FirstInterface
{
    virtual int getId() const = 0;
};

class SecondInterface
{
    virtual void setId(int id) = 0;
};

class CombinedInterface : virtual public FirstInterface, public SecondInterface
{

};

class FirstConcrete : virtual public FirstInterface
{
    virtual int getId() const
    {
        return 1;
    }
};


class CompleteConcrete : public CombinedInterface, public FirstConcrete
{
    virtual void setId(int id) { }
};


// warning: C4250:  inherits via dominance
CombinedInterface * combinedInterface = new CompleteConcrete();