X

曜彤.手记

随记,关于互联网技术、产品与创业

吉 ICP 备10004938号

“组件协作类”设计模式(C++)


该类设计模式主要用于解决组件之间的协作问题。

模板方法(Template Method)

在软件构建过程中,对于某一项任务,它常常有稳定的整体操作结构,但各个子步骤却有很多改变的需求。或者由于固有的原因(比如框架与应用之间的关系)而无法和任务的整体结构同时实现。那如何在确定稳定操作的前提下,来灵活应对各个子步骤的变化或晚期实现需求?

模式定义:定义一个操作中的算法的骨架(该骨架必须稳定),而将一些步骤延迟到子类(虚函数)。该模式使得子类可以不改变一个算法的结构,即可重新定义(override)该算法的某些特定步骤。

class FrameWork {
  virtual void startUp() { 
    std::cout << "[Framework] Initializing framework..." << std::endl;  // default implementaion.
  }
  virtual void cleanOut() { 
    std::cout << "[Framework] Cleaning out the resources, and exit..." << std::endl;  // default implementaion.
  }
 protected:
  virtual void core() = 0;  // template function, need to be done by client.
 public:
  virtual ~FrameWork() {}
  void run() {
    startUp();
    core();
    cleanOut();
  }
};
class Application : public FrameWork {
  void core() override {
    std::cout << "[User] Application is running..." << std::endl;
  }
};
int main(int argc, char **argv) {
  FrameWork *f = new Application();
  f->run();
  delete f;
  return 0;
}

策略模式(Strategy)

在软件构建过程中,某些对象使用的算法可能多种多样,经常改变。而如果将这些算法都编码到对象中,将会使对象变得异常复杂。而且有时候,支持不使用的算法也是一个性能负担。那如何在运行时根据需要透明地更改对象的算法?将算法与对象本身解耦,以避免上述问题?

模式定义:定义一系列算法,把它们一个个封装起来,并且使它们可以互相替换(变化)。该模式使得算法可以独立于使用它的客户程序(稳定)而变化(扩展、子类化)。一般可用于替换复杂重复的 if-else 结构

struct Strategy {
  virtual void strategy() = 0;
  virtual ~Strategy() {}
};
class StrategyA : public Strategy {  
  void strategy() {
    std::cout << "[Strategy] StrategyA called..." << std::endl;
  }
};
class Application {
  std::shared_ptr<Strategy> strategy;
 public:
  Application(std::shared_ptr<Strategy> strategy) : strategy(strategy) {}
  void run() {
    std::cout << "[User] Application is running..." << std::endl;
    strategy->strategy();
  }
};
int main(int argc, char **argv) {
  auto strategy = std::make_shared<StrategyA>();  // 可以使用工厂模式进行改进;
  auto app = new Application(strategy);
  app->run();
  delete app;
  return 0;
}

总结:

观察者模式(Observer / Event)

在软件构建过程中,我们需要为某些对象建立一种“通知依赖关系” —— 一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知。如果这样的依赖关系过于紧密,将使对象不能很好地抵御变化。使用面向对象技术,可以将这种依赖关系弱化,并形成一种稳定的依赖关系,从而实现软件体系结构的松耦合。

模式定义:定义对象间的一种一对多(变化)的依赖关系。以便当一个对象(Subject)的状态发生改变时,所有依赖于它的对象都得到通知并自动更新。

struct Observer {
  virtual void update(int value) = 0;
};
class Object {  // Subject + Concrete Subject.
  int v;
  std::list<Observer*> l;
 protected:
  void notify(int value) {  // notification.
    for (auto observer : l) {
      observer->update(value);
    }
  }
 public:
  Object(int v) : v(v) {};
  void attach(Observer* observer) { l.push_back(observer); }
  void detach(Observer* observer) { l.remove(observer); }
  void increase(int num) { 
    v+= num; 
    notify(v);
  }
};
struct ObserverA : public Observer {  // Concrete ObserverA.
  void update(int value) {
    std::cout << "[ObserverA] notified with value: " << value << std::endl;
  }
};
class ObserverB : public Observer {  // Concrete ObserverB.
  const Object& o;
 public:
  ObserverB(Object& o) : o(o) { o.attach(this); }  // 组合 Object 到 Observer;
  void update(int value) {
    std::cout << "[ObserverB] notified with value: " << value << std::endl;
  }
};
int main(int argc, char **argv) {
  Object o(10);
  ObserverA observerA{};
  ObserverB observerB{o};
  o.attach(&observerA);  // subscription.
  // can simulate a timer here.
  std::thread([](auto o) {
    for (auto i = 0; i < 10; ++i) {
      o->increase(100); 
    }
  }, &o).join();
  return 0;
}

总结:



这是文章底线,下面是评论
  暂无评论,欢迎勾搭 :)