Question

请参阅以下示例。

using namespace std;
//Base interface
class IBase
{
public:
    virtual void BaseMethod1() = 0;

    virtual void BaseMethod2() = 0;
};

class IEntity1 : public IBase
{
public:
    virtual void Entity1Method1() = 0;

    virtual void Entity1Method2() = 0;
};

class Entity1 : public IEntity1
{
public:
    Entity();
//IBaseMethods
    void BaseMethod1();
    void BaseMethod2();
//IEntityMethods
    void Entity1Method1();
    void Entity1Method2();
//EntityMethods
    void Method1();
    void Method2();
};

在上面的例子中，对于从IBase派生的所有其他实体需要实现BaseMethod1（）和BaseMethod2（）。因为发生了大量的代码重复？无论如何我们可以避免在衍生自它的实体中冗余实施IBase方法吗？

Answer 1

您可以将虚拟继承与默认基本实现类结合使用来封装您的默认基本行为，并使其仅由您想要的具体类继承，如下所示：

using namespace std;
//Base interface
class IBase
{
public:
    virtual void BaseMethod1() = 0;
    virtual void BaseMethod2() = 0;
};

class IEntity1 : virtual public IBase
{
public:
    virtual void Entity1Method1() = 0;
    virtual void Entity1Method2() = 0;
};

class BaseImpl : virtual public IBase
{
public:
    virtual void BaseMethod1()
    {
        ...
    }
    virtual void BaseMethod2()
    {
        ...
    }
}

class Entity1 : public IEntity1, public BaseImpl
{
public:
    Entity1();
//IEntityMethods
    void Entity1Method1();
    void Entity1Method2();
//EntityMethods
    void Method1();
    void Method2();
};

但是，有一个runtime cost与虚拟继承相关联。多重继承还伴随着一些结构性问题，例如：基类建设。

您甚至可以通过模板类获得一些乐趣，使您的课程构成更加模块化：

template<typename TEntity, typename TBaseImpl>
class ConcreteEntity: public TEntity, public TBaseImpl
{
public:
    ConcreteEntity() {}
};

class ConreteEntity1 : public ConcreteEntity<IEntity1, BaseImpl>
{
public:
    ConreteEntity1();

//IEntityMethods
    void Entity1Method1();
    void Entity1Method2();
//ConreteEntity1 Methods
    void Method1();
    void Method2();
};

Answer 2

你可以创建一个在BaseMethod1（）实现中调用的函数。

这样的事情：

void BaseMethod1_common();

class Entity1 : public IEntity1
{
public:
    Entity();
//IBaseMethods
    void BaseMethod1() { BaseMethod1_common(); }
    void BaseMethod2();
//IEntityMethods
    void Entity1Method1();
    void Entity1Method2();
//EntityMethods
    void Method1();
    void Method2();
};

Answer 3

首先，IBase值得一个虚拟的析构函数。

声明它是纯虚拟的并定义IBase：BaseMethod1（）和广积:: BaseMethod1（）。

Answer 4

如果您的目的是隐藏实现，那么唯一的选择是将代码作为库发布，然后在其他开发人员之间共享头文件。

实现全局函数，或者按照建议使用多重继承仍意味着您的实现已暴露。

但是，如果意图是减少各种类之间的耦合，那么还有另一种选择：

创建一个具有实际共享实现的类，然后创建另一个将成为它的接口的类。
此接口类将成为其他派生实体的基类。

示例代码如下所示：

//First Header and Cpp file
class Base_private
{
public:
    BaseImpl(arguments);
    ~BaseImpl();

    void BaseMethod1() {
        //Implementation
    }
    void BaseMethod2() {
        //Implementation
    }
};

//Second Header and Cpp file
class BaseInterface
{
public:
    BaseInterface(arguments);
    ~BaseInterface();

    void BaseMethod1() {
        m_pBase->BaseMethod1();
    }
    void BaseMethod2() {
        m_pBase->BaseMethod2();
    }
private:
    Base_private* m_pBase;
};

class Entity : public BaseInterface
{
public:
    Entity(arguments);
    ~Entity();

    void Method1();
    void Method2();
};

避免重复代码

4 个答案: