Question

我有一个类似于：

的类

class B{
    void x(){
        statement-block1;
        statement-block2;
        statement-block3;
        statement-block4;
    }

    void y(){
        statement-block5;
        statement-block6;
        statement-block7;
        statement-block8;
    }
}

我需要添加一个执行此操作的新类：

class C{
    void x(){
        statement-block1;
        statement-block200;
        statement-block3;
        statement-block4;
    }

    void y(){
        statement-block5;
        statement-block6;
        statement-block700;
        statement-block8;
    }
}

我正在考虑以这种方式组合可重用逻辑：

class A{
    void x(){
        statement-block1;
        statement-block2;
        u();
        statement-block4;
    }

    void y(){
        statement-block5;
        statement-block6;
        v();
        statement-block8;
    }

    virtual void u(){
        default-message;
    }

    virtual void v(){
        default-message;
    }
}

class B : A{
    void u(){
        statement-block3;
    }

    void v(){
        statement-block7;
    }
}

class C : A{
    void u(){
        statement-block200;
    }

    void v(){
        statement-block700;
    }
}

有没有更好的方法来实现这个，注入特定于子类的代码的不同/更好的方法，还是我可以使用的设计模式？将来，我可能需要添加更多类似于B和C的类。

谢谢！

Answer 1

你的方法看起来很棒。它应用了KISS，这通常是最好的设计模式！你可以这样做

virtual void u(){
    default-message;
}

virtual void v(){
    u();
}

但是，我认为这取决于你

另一种选择是组合所有类并使用std函数或函数指针来更改该函数调用。

Answer 2

这取决于你想要实现的目标。如果语句块可能在运行时（动态）中发生变化，那么使用您在示例中显示的虚拟指针，但如果这些不是动态的，那么请传递模板参数，这样您就不会付费你不能使用什么（虚拟指针）。即。

class B
{
  public:
    template <typename T>
    void x(T f)
    {
      f();
    }
};

void g(){ std::cout << "value" << std::endl;}

int main()
{
  B b {};
  b.x(g);
}

构建可重用的代码

2 个答案: