我有 C 背景，是 C++ 的新手。我有一个基本的设计问题。我有一个类(我称它为“厨师”b/c 我遇到的问题似乎与此非常相似，无论是在复杂性和问题方面)基本上都是这样工作的

    class chef
    {
    public:
          void prep();
          void cook();
          void plate();

    private: 
          char name;
          char dish_responsible_for;
          int shift_working;
          etc...
    }

在伪代码中，这是按照以下方式实现的:

   int main{
    chef my_chef;
    kitchen_class kitchen;
    for (day=0; day < 365; day++)
         {
         kitchen.opens();
         ....

         my_chef.prep();
         my_chef.cook();
         my_chef.plate();

         ....

         kitchen.closes();
         }
   }

这里的厨师职业好像是怪物职业，而且有成为怪物职业的潜力。 chef 似乎也违反了单一责任原则，所以我们应该有这样的东西:

  class employee
  {
  protected: 
        char name;
        int shift_working;
  }

  class kitchen_worker : employee
  {
  protected: 
        dish_responsible_for;
  }

  class cook_food : kitchen_worker
  {
  public:
        void cook();
        etc...
  }
  class prep_food : kitchen_worker
  {
  public:
        void prep();
        etc...
  }

和

     class plater : kitchen_worker
     {
     public:
         void plate();
     }

等...

诚然，我仍然在为如何在运行时实现它而苦苦挣扎，例如，如果 plater(或“厨师以他的身份作为 plater”)决定在晚餐服务中途回家，那么厨师必须工作一个新的转变。

这似乎与我的一个更广泛的问题有关，如果同一个人总是在这个例子中进行准备、 cooking 和装盘，那么使用这种类层次结构来模拟单个厨师所做的事情的真正实际优势是什么？我想这会遇到“害怕增加类(class)”的事情，但与此同时，现在或在可预见的 future ，我不认为完整地维护厨师类(class)是非常麻烦的。我还认为，对于代码的天真读者来说，看到 chef 对象中的三种不同方法并继续前进，实际上更容易。

我知道当/如果我们添加诸如“cut_onions()”、“cut_carrots()”等方法时，它可能会变得笨拙，也许每个方法都有自己的数据，但似乎可以处理这些方法通过使 prep() 函数更模块化。此外，似乎 SRP 得出其合乎逻辑的结论将创建一个类“onion_cutters”“carrot_cutters”等......我仍然很难看到它的值(value)，因为程序必须以某种方式确保同一个员工切洋葱和胡萝卜，这有助于在不同方法中保持状态变量相同(例如，如果员工切手指切洋葱，他就不再有资格切胡萝卜)，而在怪物对象厨师类中，似乎所有这些都得到了照顾。

当然，我知道这与有意义的“面向对象设计”无关，但在我看来，如果我们必须为每个厨师的任务提供单独的对象(这似乎不自然，因为同一个人正在执行所有这三个功能)那么这似乎将软件设计优先于概念模型。我觉得面向对象的设计在这里是有帮助的，如果我们想要，比如说，“meat_chef”“sous_chef”“three_star_chef”可能是不同的人。此外，与运行时问题相关的是，在单一责任原则的严格应用下，似乎存在复杂性开销，必须确保构成基类员工的底层数据发生变化，并且这种变化是反射(reflect)在后续的时间步长中。

因此，我很想或多或少地保留它的原样。如果有人可以澄清为什么这是一个坏主意(如果您对如何最好地进行有建议)，我将非常感激。

最佳答案

为了避免现在和将来滥用类继承关系，您实际上应该只在存在是关系时才使用它。作为你自己，“cook_food 是一个 kitchen_worker”。它显然在现实生活中没有意义，在代码中也没有。 “cook_food”是一个 Action ，因此创建一个 Action 类并将其子类化可能是有意义的。

拥有一个新类只是为了添加新方法，如 cook() 和 prep() 无论如何，并不是对原始问题的真正改进 - 因为你已经完成的是将方法包装在一个类中。您真正想要的是进行抽象来执行这些操作中的任何一个 - 所以回到操作类。

class action {
    public:
        virtual void perform_action()=0;
}

class cook_food : public action {
    public:
        virtual void perform_action() {
            //do cooking;
        }
}

然后可以为厨师提供一系列操作，以按照您指定的顺序执行。例如，队列。

class chef {
    ...
        perform_actions(queue<action>& actions) {
            for (action &a : actions) {
                a.perform_action();
            }
        }
    ...
}

这通常称为 Strategy Pattern .它通过允许您在不修改现有类的情况下添加新操作来促进开放/封闭原则。

您可以使用的替代方法是 Template Method ，您可以在其中指定一系列抽象步骤，并使用子类来实现每个步骤的特定行为。

class dish_maker {
    protected:
        virtual void prep() = 0;
        virtual void cook() = 0;
        virtual void plate() = 0;

    public:
        void make_dish() {
            prep();
            cook();
            plate();
        }
}

class onion_soup_dish_maker : public dish_maker {
    protected:
        virtual void prep() { ... }
        virtual void cook() { ... }
        virtual void plate() { ... }
}

可能适用于此的另一个密切相关的模式是 Builder Pattern

这些模式还可以减少 Sequential Coupling反模式，因为很容易忘记调用某些方法，或者以正确的顺序调用它们，尤其是当您多次这样做时。您还可以考虑将 kitchen.opens() 和 closes() 放入类似的模板方法中，这样您就不必担心 closes() 被调用。

在为 onion_cutter 和 carrot_cutter 创建单独的类时，这实际上不是 SRP 的逻辑结论，但实际上违反了它 - 因为您正在创建负责切割的类，并保存一些关于什么的信息他们正在切割。切洋葱和胡萝卜都可以抽象为单个切割 Action - 您可以指定要切哪个对象，如果每个对象需要特定代码，还可以为每个单独的类添加重定向。

第一步是创建一个抽象来表示某些东西是可切割的。子类化的是关系是候选关系，因为胡萝卜是可切割的。

class cuttable {
    public:
        virtual void cut()=0;
}

class carrot : public cuttable {
    public:
      virtual void cut() {
          //specific code for cutting a carrot;
      }
}

切割 Action 可以采用可切割对象并执行适用于所有可切割对象的任何常见切割 Action ，也可以应用每个对象的特定切割行为。

class cutting_action : public action {
    private:
        cuttable* object;
    public:
        cutting_action(cuttable* obj) : object(obj) { }
        virtual void perform_action() {
            //common cutting code
            object->cut(); //specific cutting code
        }
}

关于C++ 帮助重构一个怪物类，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13171585/