c++ - 指向组合接口(interface)的指针 - 指向实现一个接口(interface)并从另一个接口(interface)的实现扩展的类

Question

我有两个接口(interface):

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

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

这是一个组合界面:

class CombinedInterface : public FirstInterface, public SecondInterface
{

};

这是第一个接口(interface)的具体类:

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

这是我在评论中提到的基于虚拟继承的解决方案:

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();
}

使用虚拟继承，唯一需要的改变(除了房间里的大象)是 CompleteConcrete从 CombinedInterface 乘法继承, 而不是 SecondInterface .你可以这样想:with CompleteConcreate图中，现在支持CombinedInterface ，而不仅仅是添加 SecondInterface .

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

1. 因为它太强大了，所以很容易被误用，导致各种问题。

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

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

附言我还会提到刚刚想到的另一个替代解决方案。如果，说你有你的 CombinedInterface只是为了某些特定功能可能需要它，例如:

 void somefunction(CombinedInterface &object);

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

做一个小改动:

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

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

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 , 并简单地将实现这两​​个接口(interface)的任何对象传递给 somefunction() ，还有你的 real_somefunction()将使用一个或另一个参数来调用适当的接口(interface)。

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

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

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

只是一个起点。