c++ - 策略模式与继承

Question

我们有一些算法可以应用于某些数据，并且该算法可能会在同一数据上应用多次。我们有两种方法可以做到这一点:

1. 保持数据和逻辑分离

   class Algo{
   public:
       virtual int execute(data_object) = 0;
   };
   
   class AlgoX: public Algo{
   public:
       int execute(data_object);
   };
   
   class AlgoY: public Algo{
   public:
       int execute(data_object);
   };
   
   class Data{
   public:
       string some_values;
       ...
       void* algo_specific_data; //It will contain some algo specific data (like state of algo)
       Algo* algo_ptr; //Reference of Algo
   
       int execute(){
           algo_ptr->execute(this);
       }
   };
   
   some_function(){
       Data* data_object = create_data(algo_ptr, algo_specific_data); //A dummy function which creates an object of type data.
       data_object->execute();
   }
   

2. 通过继承绑定(bind)数据和逻辑

   class Data{
   public:
       string some_values;
       ...
       virtual int execute() = 0;
   };
   
   class DataWithAlgoX : public Data{
   public:
       AlgoX_Relateddata algo_related_data; //some algo specific data (like state of algo)
       int execute();
   }
   
   class DataWithAlgoY : public Data{
   public:
       AlgoY_Relateddata algo_related_data; //some algo specific data (like state of algo)
       int execute();
   }
   
   some_function(){
       Data* data_object = create_data(algo_type); //A dummy function which creates an object of type data.
       data_object->execute();
   }
   

哪种设计更好，如果

1. 我们可以在对数据多次调用 algo->execute() 之间更改算法类型 (但切换不会很频繁，只有在某些特定场景下才需要)。
   有些人可能会指出算法的切换会使我们重新创建data_object。 如果架构 2 比 1 好得多，我们愿意承担额外的负担。

2. 我们不会在多次调用 data 上的 algo->execute() 之间更改算法类型。

Answer 1

在同一类(class)中混合数据和算法(非常)糟糕的做法。 打破了单一责任原则。

https://en.wikipedia.org/wiki/Single_responsibility_principle

如果你想将多种类型的数据与多种算法结合起来 使用调解器之类的东西。思路是分别定义Data和Algorithms，在mediator中定义它们之间的交互。

https://en.wikipedia.org/wiki/Mediator_pattern

在我看来，设计 2 比设计 1 差得多。即使在设计 1 的情况下，我也会删除对数据类中算法的引用。它只介绍了High Coupling，i。 e.类之间的依赖关系会影响另一个类的变化:

https://en.wikipedia.org/wiki/Coupling_(computer_programming)

(和google“Low coupling, high cohesion”，这是另一个OOP原则)。

Mediator 也可以解决耦合问题。