C++设计：减少深层类层次结构中的耦合

Question

请考虑这个类层次结构：

#include <iostream>

struct Base
{    
    Base(int arg1, int arg2, int arg3, int arg4)
    {
        std::cout << "Base::Base:" << arg1 << "," << arg2 << "," << arg3 << "," << arg4 << std::endl;
    }
    void BaseDoWork()
    {
        std::cout << "Base::BaseDoWork" << std::endl;
    }
};

struct Derived1:public Base
{
    Derived1(int arg1, int arg2, int arg3, int arg4):Base(arg1, arg2, arg3, arg4){}
    void DerivedDoWork()
    {
        BaseDoWork();
    }
};

struct Derived2:public Derived1
{
    Derived2(int arg1, int arg2, int arg3, int arg4):Derived1(arg1, arg2, arg3, arg4){}
};

int main(int argc, char *argv[])
{
    Derived2 myDerived2(1,2,3,4);
    myDerived2.DerivedDoWork();
    return 0;
}

Derived1 类的耦合比我想的要多：它必须知道如何构造“Base”类。在较深的层次结构中，这意味着将“基”类构造函数的参数一直沿类层次结构向下传播。更改“基”类构造函数需要更改所有派生类。

我对这个类层次结构的目标是：

1. Derived1 需要基类中的 BaseDoWork() 方法，但不需要知道如何构造基类。

2. Derived2 知道如何构造“Base”类。

理想情况下，我想让 Derived1 成为接受任何具有可访问“BaseDoWork()”方法的基类的模板，如下所示：

template <T> struct Derived1:public T
{
    void DerivedDoWork()
    {
        BaseDoWork();
    }
};

但是，如果我将上述模板实例化为Derived1<Base>，如果不向 Derived1 添加“Base”构造函数参数的知识，我将看不到如何构造“Base”类。

Answer 1

假设这是真正的层次结构，如果Derived1 是Base 派生类，则必须知道如何构造父类（Base）。

据我了解，也许我错了，如果Derived1 不是真正的Base 派生（子）类，只需要知道它的接口，就不需要知道如何构造@987654326 @ 实例。所以你可以定义 Derived1 如下：

struct Derived1
{
    Derived1(int arg1, int arg2, int arg3, int arg4)
    {}

    .....
};

只有Base派生类需要知道如何构造Base：

struct Derived2 : public Base
{
    Derived2(int arg1, int arg2, int arg3, int arg4) : 
        Base(arg1, arg2, arg3, arg4)
    {}

    .....
};

现在，如果Derived2 真的是Derived1 孩子，必须知道如何创建它的父母。之前的代码变成了：

struct Derived2 : public Base, public Derived1
{
    Derived2(int arg1, int arg2, int arg3, int arg4) : 
        Base(arg1, arg2, arg3, arg4),
        Derived1(arg1, arg2, arg3, arg4)
    {}

    .....
};

如果你必须使用Derived1中的Base::BaseDoWork()方法，你可以定义类如下：

struct Base
{    
    Base(int arg1, int arg2, int arg3, int arg4)
    {
        std::cout << "Base::Base:" << arg1 << "," << arg2 << "," << arg3 << "," << arg4 << std::endl;
    }

    virtual void BaseDoWork()
    {
        std::cout << "Base::BaseDoWork" << std::endl;
    }
};

struct Derived1
{
    Derived1(int arg1, int arg2, int arg3, int arg4)
    {}

    template <typename T>
    void DerivedDoWork(T & base)  // only knows T interface
    {
      base.BaseDoWork();
    }
};

struct Derived2 : public Base, public Derived1
{
    Derived2(int arg1, int arg2, int arg3, int arg4) : 
      Base(arg1, arg2, arg3, arg4),
      Derived1(arg1, arg2, arg3, arg4)
    {}

    virtual void DerivedDoWork()
    {
      Derived1::DerivedDoWork<Base>(*(static_cast<Base *>(this)));
    }
};

主要保持不变。

您可能需要查看此层次结构。

Answer 2

当你让public从Base继承Derived1时，结果是Derived1已经知道如何构造Base，所以如果你想要Derived1不知道如何构造Base ，也许最好不要从Base继承它？相反，将Base 分隔为某种表演者。

考虑一下这段代码，我并不认为这是解决方案，但也许它会让你产生其他想法（类的名称相同）：

#include <iostream>

struct Base
{
    Base()
    {
        std::cout << "Base::Base:" << std::endl;
    }
    Base(int arg1, int arg2, int arg3, int arg4)
    {
        std::cout << "Base::Base:" << arg1 << "," << arg2 << "," << arg3 << "," << arg4 << std::endl;
    }
    void DoWork()
    {
        std::cout << "Base::BaseDoWork" << std::endl;
    }
};

template <typename T>
struct Derived1
{
    T object;

    Derived1(T obj){ object = obj; }
    void DerivedDoWork()
    {
        object.DoWork();
    }
};

template <typename T>
struct Derived2 : public Derived1<T>
{
    Derived2(int arg1, int arg2, int arg3, int arg4) : Derived1( T(arg1, arg2, arg3, arg4))
    { }
};

int main(int argc, char *argv[])
{
    Derived2<Base> myDerived2(1,2,3,4);
    myDerived2.DerivedDoWork();
    return 0;
}