Question

我想要的是让一个对象具有以特定方式实现的一些方法，而其他方法实现不同。我决定使用两个接口。我们称之为InterfaceA和InterfaceB。两个接口都可以有各种实现。让我展示代码：

class InterfaceA
{
  public:
    virtual int method_A_foo(void) = 0;
    virtual int method_A_bar(void) = 0;
};

class InterfaceB
{
  public:
    virtual int method_B_foo(void) = 0;
    virtual int method_B_bar(void) = 0;
};

现在我有几个InterfaceA的实现，假设我有IA_instance1，IA_instance2。这些实现是InterfaceB的基础，它使用InterfaceA中的方法，实现：

class IA_instance1 : public InterfaceA
{
  public:
    int method_A_foo(void);
    int method_A_bar(void);
};

class IA_instance2 : public InterfaceA
{
  public:
    int method_A_foo(void);
    int method_A_bar(void);
};

class IB_instance : public InterfaceB
{
  public:

    /* in implementation of this method i want to call method_A_foo() twice */
    int method_B_foo(void);

    /* in implementation of this method i want to call method_A_foo() 4 times and method_A_bar() one time*/
    int method_B_bar(void);
};

我所做的是我创建了一个包装两个接口的抽象类。此抽象类中存在InterfaceA实现，并且InterfaceB实现被移动到派生类：

class InterfaceBase : public InterfaceA, InterfaceB
{
  private:
    InterfaceA * m_interfaceA;

  public:
    InterfaceBase(InterfaceA * _interfaceA)
    {
      this->m_interfaceA = _interfaceA;
    }

    int method_A_foo(void)
    {
      return this->m_interfaceA->method_A_foo();
    }

    int method_A_bar(void)
    {
      return this->m_interfaceA->method_A_bar();
    }

    virtual int method_B_foo(void) = 0;
    virtual int method_B_bar(void) = 0;
};


class IB_instance1 : public InterfaceBase
{
  public:
    IB_instance1(InterfaceA * _interafceA)
      : InterfaceBase(_interafceA)
    { }

    int method_B_foo(void);
    int method_B_bar(void);
};

现在我需要的是实现InterfaceA，并将其传递给构造函数IB_instance1。我不创建实现两个接口的类，因此我不复制InterfaceA实现。我使用InterfaceA的一个实例，然后将其传递给InterfaceBase包装器。我可以这样做：

InterfaceA * instanceA1 = new IA_instance1();
InterfaceBase * instanceB1 = new IB_instance1(instanceA1);

我有以下问题：

以这种方式解决这个问题是个好主意吗？我可以做得更好吗？
我需要在virtual int中复制InterfaceBase声明吗？如果我删除它们，我将无法在转换为InterfaceB后调用InterfaceBase *方法。我可以调用InterfaceA方法，但对于InterfaceB，我必须在virtual int

InterfaceBase

然而，对我来说这似乎是好方法，我认为编写声明和定义并使用单独的.h和.cpp文件是可怕的。

Answer 1

我需要在InterfaceBase中复制虚拟int声明吗？如果我删除它们，我会在转换为InterfaceB后无法调用InterfaceBase *方法。我可以调用InterfaceA方法，但对于InterfaceB，我必须在InterfaceBase中放入虚拟int声明。

这是因为您私下继承InterfaceB而不是公开。将您的代码更改为

class InterfaceBase : public InterfaceA, public InterfaceB
{
    /* Your implementation without repeating InterfaceB */
};

从两个接口实现创建实例

1 个答案: