Question

我已经在很多地方读过SRP是一个很好的应用原则，我想在我的项目中应用它。

实际上，它是一个游戏，我的对象基本上有两个函数update和draw，因此它们有两个响应（定义为＆＃34;改变的原因＆＃34; ）。它看起来像这样：

class Object {
    public:
        void update() {
            // implementation...
        }

        void draw() {
            // implementation...
        }
};

我们假设我选择使用组件设计模式将update和draw拆分为UpdateComponent和DisplayComponent，使用这些的对象组件仍然会有update / draw对，但不再是它们的实现。所以它现在看起来像这样：

class Object {
    public:
        void update() {
            m_updateComponent.update(*this);
        }

        void draw() {
            m_displayComponent.draw(*this);
        }

    private:
        UpdateComponent m_updateComponent;

        DisplayComponent m_displayComponent;
};

在此实现中，update和draw被视为对象和的组件的责任，还是仅被视为组件的责任，因此对象与SRP一致？< / p>

Answer 1

您已经考虑了改变＆＃34;的理由。并移动它。现在，如果需要更改绘图或更新，则无需更改Object类。这与SRP一致。

但是，你有一些不必要的耦合。您可以判断，因为DisplayComponent和Object之间存在双向依赖关系。为什么Object需要了解（依赖于）DisplayComponent甚至UpdateComponent？

你有：

DisplayComponent <--> Object

（这些线代表一种依赖关系，即你不能在没有指向另一个的情况下编译一个）

你只需要：

DisplayComponent ---> Object

但是，如果你不能从对象那里做到这一点，你将如何到DisplayComponent致电draw？

ObjectContainer          --\ 
   --> UpdateComponent   ---> Object
   --> DisplayComponent  --/

所以我介绍了一个新的ObjectContainer类，它知道（取决于）UpdateComponent，DisplayComponent和Object。

您的外部游戏循环只能访问ObjectContainer，只能通过m_updateComponent更改游戏状态，并通过m_displayComponent进行抽奖。 Object现在唯一的责任就是坚持对象的状态：

class Object {
    public:
      //getters/setters maybe

    private:
        int x;
        int y;
        float speed;
        float health;
        //etc
};

class ObjectContainer {
    public:
        void update() {
            m_updateComponent.update(object);
        }

        void draw() {
            m_displayComponent.draw(object);
        }

    private:
        Object object;

        UpdateComponent m_updateComponent;

        DisplayComponent m_displayComponent;
};

上述ObjectContainer与您的Object非常相似，但没有双向依赖。

SRP是否与单个类的可能操作或其中的实现有关？

1 个答案: