Boolan微专业-设计模式（Week03）

2018-04-02 本文已影响0人 GoMomi

内容概要

本周主要介绍了的设计模式类型有：对象性能、状态变化、数据结构、行为变化和领域规则。并对整个课程进行了一个总结，包括设计模式的一个目标、两种手段、八大原则等。

对象性能

Singleton 单件模式：绕过构造器，提供一种机制来保证一个类只有一个实例，提高性能和效率
Flyweight 享元模式：避免大量细粒度对象的性能消耗。各种单例对象的集合，中心思想是有就给，没有才创建。

状态变化

State 状态模式：解耦对象操作和状态转换间的紧耦合，与Stategy策略模式异曲同工，将状态对象化。在每次执行完操作后，需改变State，保证后续逻辑的正确运行。
Memento 备忘录：较为过时的模式，旨在保证封装性的同时，实现对对象状态的良好保存和恢复。如今的语言可利用序列化等方式实现上述需求，且效率更高。

数据结构

Composite 组合模式：解耦客户代码与复杂的对象容器结构。本质是一个树形结构，核心在于复合节点依次遍历子节点，叶子节点则执行具体操作。
Iterator 迭代器：实现对容器的透明遍历。更推荐用模板实现而非面向对象。(模板是编译时多态、虚函数是运行时多态，前者效率更高)
Chain of Resposibility 职责链：解耦请求者和接受者。利用单向列表，让请求在接受链上传递直到被处理。

行为变化

Command 命令模式：解耦“行为请求者”和“行为实现者”，将“行为”对象化，使之可以被传递、存储和组合。类似C++中的函数对象。
Vistor 访问器：当子类数量确定时，解决类层次结构中行为增加的问题。核心是Double Dispatch，条件较为苛刻，使用较少。

领域规则

Interpreter 解析器：将问题表达为某种语法规则下的句子，然后构建一个解析器去解释这样的句子。如字符串的四则远算，人民币的大小写转换等。其难点是应用场合的定义。

五、对象性能

面向对象解决了“抽象”的问题，但是必不可免地要付出一定的代价。通常这些成本可以忽略不计，但有些情况还是需谨慎处理。下列两种某事主要就是为了解决“性能”问题。

14.Singleton 单件模式

有些特殊的类，必须保证其在系统中只存在一个实例，才能确保逻辑的正确性、以及良好的效率。

保证一个类仅有一个实例，并提供一个该实例的全局访问点。 ———— 《设计模式》 GOF

核心思想是将构造函数和拷贝构造定义为私有的，然后提供一个静态的接口和变量供外界访问，有就直接给，没有才创建。
根据使用情况分为线程非安全、线程安全、reorder不安全等版本，简单情况下

class Singleton {
 private:
  Singleton();
  Singleton(const Singleton& other);

 public:
  static Singleton* getInstance();
  static Singleton* m_instance;
};

Singleton* Singleton::m_instance = nullptr;

//线程非安全版本
Singleton* Singleton::getInstance() {
  if (m_instance == nullptr) {
    m_instance = new Singleton();
  }
  return m_instance;
}

//线程安全版本，但锁的代价过高
//读变量的操作是不需要加锁的，如果ThreadA进入函数，获取锁。这时ThradB进入函数，其目的只时为了获取m_instance变量，却要等待ThreadA锁的释放，浪费了资源。
Singleton* Singleton::getInstance() {
  Lock lock; // 锁的局部变量，函数结束时会自动释放
  if (m_instance == nullptr) {
    m_instance = new Singleton();
  }
  return m_instance;
}

//双检查锁，但由于内存读写reorder不安全
//reorder---new操作：(分配内存、调用构造器、返回指针)的顺序在指令层有可能会优化为：(分配内存、返回指针、调用构造器)
//线程是在指令层抢时间片的
Singleton* Singleton::getInstance() {
  if (m_instance == nullptr) {
    Lock lock; // 为nullptr时才加锁，避免读操作的加锁
    if (m_instance == nullptr) { // 二次判断，否则依然会有多线程多次new的问题
      m_instance = new Singleton();
    }
  }
  return m_instance;
}

// C++ 11版本之后的跨平台实现 (volatile)
// volatile指定编译器不要进行new顺序的优化
std::atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;

Singleton* Singleton::getInstance() {
  Singleton* tmp = m_instance.load(std::memory_order_relaxed);
  std::atomic_thread_fence(std::memory_order_acquire);  //获取内存fence
  if (tmp == nullptr) {
    std::lock_guard<std::mutex> lock(m_mutex);
    tmp = m_instance.load(std::memory_order_relaxed);
    if (tmp == nullptr) {
      tmp = new Singleton;
      std::atomic_thread_fence(std::memory_order_release);  //释放内存fence
      m_instance.store(tmp, std::memory_order_relaxed);
    }
  }
  return tmp;
}

15.Flyweight 享元模式

避免系统中充斥大量细粒度的对象所造成的性能消耗。如字体，没必要为每一个字符都定义一个字体对象。

提供一个接口，然该接口负责创建一系列“相关或者相互依赖的对象，无需指定它们具体的类。 ———— 《设计模式》 GOF

其核心思想是构建一个单例对象的集合，有就给，没有创建。类似字体这种ReadOnly类型的对象就和适合享元模式。

class Font {
 private:
  // unique object key
  string key;

  // object state
  //....

 public:
  Font(const string& key) {
    //...
  }
};

class FontFactory {
 private:
  map<string, Font*> fontPool;

 public:
  Font* GetFont(const string& key) {
    map<string, Font*>::iterator item = fontPool.find(key);

    if (item != footPool.end()) {
      return fontPool[key];
    } else {
      Font* font = new Font(key);
      fontPool[key] = font;
      return font;
    }
  }

  void clear() {
    //...
  }
};

六、状态变化

对对象的状态变化进行有效管理，从而维持高层模块的稳定。

16.State 状态模式

解耦对象操作和状态转化间的紧耦合。将不同对象不同状态下对应的不同行为与对象本身剥离开来。

允许一个对象在其内部状态改变时改变它的行为。从而使对象看起来视乎修改了其行为。 ———— 《设计模式》 GOF。

核心逻辑与Stategy策略模式相似，都是通过虚函数绑定不同状态下的对应行为，只不过在每次执行完毕后需设置对象的当前状态，以保证逻辑的正确进行。
虚函数调用本质就是一个运行时的if...else

class NetworkState {
 public:
  NetworkState* pNext;
  virtual void Operation1() = 0;
  virtual void Operation2() = 0;

  virtual ~NetworkState() {}
};

class OpenState : public NetworkState {
  static NetworkState* m_instance;

 public:
  static NetworkState* getInstance() {
    if (m_instance == nullptr) {
      m_instance = new OpenState();
    }
    return m_instance;
  }

  void Operation1() {
    //**********
    pNext = CloseState::getInstance();
  }

  void Operation2() {
    //..........
    pNext = ConnectState::getInstance();
  }
};

class CloseState : public NetworkState {
  //...
};

class NetworkProcessor {
  NetworkState* pState;

 public:
  NetworkProcessor(NetworkState* pState) { this->pState = pState; }

  void Operation1() {
    //...
    pState->Operation1();
    pState = pState->pNext;
    //...
  }

  void Operation2() {
    //...
    pState->Operation2();
    pState = pState->pNext;
    //...
  }
};

17.Mmento 备忘录

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可以将该对象恢复到原先保存的状态。 ———— 《设计模式》 GOF

ClientApp直接使用Proxy进行访问，而对RealSubject的复杂返回逻辑则有Proxy负责，对用户透明。
由于现代语言运行时都具有相当的对象序列化支持，因此往往采用效率较高、又较容易正确实现的序列化方案来实现Memento模式，不再用面向对象的方法去实现。

class Memento {
  string state;
  //..
 public:
  Memento(const string& s) : state(s) {}
  string getState() const { return state; }
  void setState(const string& s) { state = s; }
};

class Originator {
  string state;
  //....
 public:
  Originator() {}
  Memento createMomento() {
    Memento m(state);  // 拍照：具体的实现过程可能相当复杂
    return m;
  }
  void setMomento(const Memento& m) { state = m.getState(); }
};

int main() {
  Originator orginator;

  //捕获对象状态，存储到备忘录
  Memento mem = orginator.createMomento();

  //... 改变orginator状态

  //从备忘录中恢复
  orginator.setMomento(memento);
}

七、数据结构

将复杂的数据结构封装在对象内部，在外部提供统一的接口，来实现与特定数据结构无关的访问。

18.Composite 组合模式

解耦客户代码和复杂的对象容器结构。

将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得永无对单个对象和组合对象的使用具有一致性（稳定）。 ———— 《设计模式》 GOF。

本质是一个树形结构，核心在于复合节点依次遍历子节点，叶子节点则执行具体操作。对外则提供一致的调用接口。

#include <algorithm>
#include <iostream>
#include <list>
#include <string>

using namespace std;

// 抽象积累
class Component {
 public:
  virtual void process() = 0;
  virtual ~Component() {}
};

//树节点
class Composite : public Component {
  string name;
  list<Component*> elements;

 public:
  Composite(const string& s) : name(s) {}

  void add(Component* element) { elements.push_back(element); }
  void remove(Component* element) { elements.remove(element); }

  void process() {
    // 1. process current node

    // 2. process leaf nodes
    for (auto& e : elements) e->process();  //多态调用
  }
};

//叶子节点
class Leaf : public Component {
  string name;

 public:
  Leaf(string s) : name(s) {}

  void process() {
    // process current node
  }
};

void Invoke(Component& c) {
  //...
  c.process();
  //...
}

int main() {
  Composite root("root");
  Composite treeNode1("treeNode1");
  Composite treeNode2("treeNode2");
  Leaf leat1("left1");

  root.add(&treeNode1);
  treeNode1.add(&treeNode2);
  treeNode2.add(&leaf1);

  Invoke(root);
  Invoke(leaf1);
  Invoke(treeNode2);
}

19.Iterator 迭代器

对容器内部对象的“透明遍历”，也为“同一种算法在多种集合对象上进行操作”提供了可能。

提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露（稳定）该对象的内部表示。 ———— 《设计模式》 GOF。

重点在于“透明遍历”的思想，现在已经不再用面向对象的方式来实现了。取而代之的是利用泛型编程中的“模板”实现，性能和效率要更优。
“模板”可以看做是一种编译时的多态。
迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。如Lua中边迭代边赋值。

template <typename T>
class Iterator {
 public:
  virtual void first() = 0;
  virtual void next() = 0;
  virtual bool isDone() const = 0;
  virtual T& current() = 0;
};

template <typename T>
class MyCollection {
 public:
  Iterator<T> GetIterator() {
    //...
  }
};

template <typename T>
class CollectionIterator : public Iterator<T> {
  MyCollection<T> mc;

 public:
  CollectionIterator(const MyCollection<T>& c) : mc(c) {}

  void first() override {}
  void next() override {}
  bool isDone() const override {}
  T& current() override {}
};

void MyAlgorithm() {
  MyCollection<int> mc;

  Iterator<int> iter = mc.GetIterator();

  for (iter.first(); !iter.isDone(); iter.next()) {
    cout << iter.current() << endl;
  }
}

20.Chain of Resposibility 职责链

一个请求可能被多个对象处理，但每个请求在运行时只能有一个接受者，为了避免显示指定带来的紧耦合，可用职责链处理，让请求的接受者自己在运行时决定谁来处理请求。

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。 ———— 《设计模式》 GOF。

大多情况向会把职责链看成是一种数据结构，而非模式。其核心在于职责分派，可以在运行时动态添加/修改请求的处理职责。

#include <iostream>
#include <string>

using namespace std;

enum class RequestType { REQ_HANDLER1, REQ_HANDLER2, REQ_HANDLER3 };

class Reqest {
  string description;
  RequestType reqType;

 public:
  Reqest(const string &desc, RequestType type)
      : description(desc), reqType(type) {}
  RequestType getReqType() const { return reqType; }
  const string &getDescription() const { return description; }
};

class ChainHandler {
  ChainHandler *nextChain;
  void sendReqestToNextHandler(const Reqest &req) {
    if (nextChain != nullptr) nextChain->handle(req);
  }

 protected:
  virtual bool canHandleRequest(const Reqest &req) = 0;
  virtual void processRequest(const Reqest &req) = 0;

 public:
  ChainHandler() { nextChain = nullptr; }
  void setNextChain(ChainHandler *next) { nextChain = next; }

  void handle(const Reqest &req) {
    if (canHandleRequest(req))
      processRequest(req);
    else
      sendReqestToNextHandler(req);
  }
};

class Handler1 : public ChainHandler {
 protected:
  bool canHandleRequest(const Reqest &req) override {
    return req.getReqType() == RequestType::REQ_HANDLER1;
  }
  void processRequest(const Reqest &req) override {
    cout << "Handler1 is handle reqest: " << req.getDescription() << endl;
  }
};

class Handler2 : public ChainHandler {
 protected:
  bool canHandleRequest(const Reqest &req) override {
    return req.getReqType() == RequestType::REQ_HANDLER2;
  }
  void processRequest(const Reqest &req) override {
    cout << "Handler2 is handle reqest: " << req.getDescription() << endl;
  }
};

class Handler3 : public ChainHandler {
 protected:
  bool canHandleRequest(const Reqest &req) override {
    return req.getReqType() == RequestType::REQ_HANDLER3;
  }
  void processRequest(const Reqest &req) override {
    cout << "Handler3 is handle reqest: " << req.getDescription() << endl;
  }
};

int main() {
  Handler1 h1;
  Handler2 h2;
  Handler3 h3;
  h1.setNextChain(&h2);
  h2.setNextChain(&h3);

  Reqest req("process task ... ", RequestType::REQ_HANDLER3);
  h1.handle(req);
  return 0;
}

八、行为变化

解耦组件的行为和组件本身，支持组件行为的变化。

21.Command 命令模式

解耦“行为请求者”和“行为实现者”。有些过时了，通常采用函数对象来替代命令模式。

将一个请求（行为）封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。 ———— 《设计模式》 GOF。

将“行为”对象化，即“代码”对象化，使之可以被传递、存储和组合。类似C++中的函数对象。
Command模式与C++中的函数对象有些类似。但两者定义行为接口的规范有所区别；Command以面向对象中的“接口-实现”来定义行为接口规范，更严格，但有性能损失（虚函数）；C++函数对象以函数签名来定义行为接口规范，更灵活，性能更高（编译时多态，模板）

class Command {
 public:
  virtual void execute() = 0;
};

class ConcreteCommand1 : public Command {
  string arg;

 public:
  ConcreteCommand1(const string &a) : arg(a) {}
  void execute() override { cout << "#1 process..." << arg << endl; }
};

class ConcreteCommand2 : public Command {
  string arg;

 public:
  ConcreteCommand2(const string &a) : arg(a) {}
  void execute() override { cout << "#2 process..." << arg << endl; }
};

class MacroCommand : public Command {
  vector<Command *> commands;

 public:
  void addCommand(Command *c) { commands.push_back(c); }
  void execute() override {
    for (auto &c : commands) {
      c->execute();
    }
  }
};

int main() {
  ConcreteCommand1 command1(receiver, "Arg ###");
  ConcreteCommand2 command2(receiver, "Arg $$$");

  MacroCommand macro;
  macro.addCommand(&command1);
  macro.addCommand(&command2);

  macro.execute();
}

22.Visitor 访问器

避免在基类中增加新的行为（方法）导致类层次结构的巨大改变。条件较为严格，需提前知道子类对象的个数，应用场景较少。

表示一个作用于某对象结构中的各元素的操作。使得可以在不改变（稳定）各元素类的前提下定义（扩展）作用于这些元素的新操作（变化）。 ———— 《设计模式》 GOF。

其核心思想是Double Dispatch，也是将操作封装成了对象。统一调用的接口，在不同的情况下，传入不同的操作-Visitor，达到扩展行为的目的。

class Visitor;

class Element {
 public:
  virtual void accept(Visitor& visitor) = 0;  //第一次多态辨析

  virtual ~Element() {}
};

class ElementA : public Element {
 public:
  void accept(Visitor& visitor) override { visitor.visitElementA(*this); }
};

class ElementB : public Element {
 public:
  void accept(Visitor& visitor) override {
    visitor.visitElementB(*this);  //第二次多态辨析
  }
};

class Visitor {
 public:
  virtual void visitElementA(ElementA& element) = 0;
  virtual void visitElementB(ElementB& element) = 0;

  virtual ~Visitor() {}
};

//==================================

//扩展1
class Visitor1 : public Visitor {
 public:
  void visitElementA(ElementA& element) override {
    cout << "Visitor1 is processing ElementA" << endl;
  }

  void visitElementB(ElementB& element) override {
    cout << "Visitor1 is processing ElementB" << endl;
  }
};

//扩展2
class Visitor2 : public Visitor {
 public:
  void visitElementA(ElementA& element) override {
    cout << "Visitor2 is processing ElementA" << endl;
  }

  void visitElementB(ElementB& element) override {
    cout << "Visitor2 is processing ElementB" << endl;
  }
};

int main() {
  Visitor2 visitor;
  ElementB elementB;
  elementB.accept(visitor);  // double dispatch

  ElementA elementA;
  elementA.accept(visitor);

  return 0;
}

九、领域模式

在特定的领域中，可将问题抽象为语法规则，从而给出该领域下的一般性解决方案。

23. Interpreter 解析器

将特定领域的问题表达为某种语法规则下的句子，然后构建一个解释器来解释这样的句子，从而达到解决问题的目的。

给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。 ———— 《设计模式》 GOF。

如“字符串实现四则运算”，“人民币大写转数字等”。其难点是应用场合的确定，比较适合简单的文法表示，对于复杂的文法表示会产生比较大的类层次结构，往往需要借助语法分析生成器这样的工具。

// 实现一个字符串加减运算
class Expression {
 public:
  virtual int interpreter(map<char, int> var) = 0;
  virtual ~Expression() {}
};

//变量表达式
class VarExpression : public Expression {
  char key;

 public:
  VarExpression(const char& key) { this->key = key; }

  int interpreter(map<char, int> var) override { return var[key]; }
};

//符号表达式
class SymbolExpression : public Expression {
  // 运算符左右两个参数
 protected:
  Expression* left;
  Expression* right;

 public:
  SymbolExpression(Expression* left, Expression* right)
      : left(left), right(right) {}
};

//加法运算
class AddExpression : public SymbolExpression {
 public:
  AddExpression(Expression* left, Expression* right)
      : SymbolExpression(left, right) {}
  int interpreter(map<char, int> var) override {
    return left->interpreter(var) + right->interpreter(var);
  }
};

//减法运算
class SubExpression : public SymbolExpression {
 public:
  SubExpression(Expression* left, Expression* right)
      : SymbolExpression(left, right) {}
  int interpreter(map<char, int> var) override {
    return left->interpreter(var) - right->interpreter(var);
  }
};

Expression* analyse(string expStr) {
  stack<Expression*> expStack;
  Expression* left = nullptr;
  Expression* right = nullptr;
  for (int i = 0; i < expStr.size(); i++) {
    switch (expStr[i]) {
      case '+':
        // 加法运算
        left = expStack.top();
        right = new VarExpression(expStr[++i]);
        expStack.push(new AddExpression(left, right));
        break;
      case '-':
        // 减法运算
        left = expStack.top();
        right = new VarExpression(expStr[++i]);
        expStack.push(new SubExpression(left, right));
        break;
      default:
        // 变量表达式
        expStack.push(new VarExpression(expStr[i]));
    }
  }

  Expression* expression = expStack.top();

  return expression;
}

void release(Expression* expression) {
  //释放表达式树的节点内存...
}

int main(int argc, const char* argv[]) {
  string expStr = "a+b-c+d-e";
  map<char, int> var;
  var.insert(make_pair('a', 5));
  var.insert(make_pair('b', 2));
  var.insert(make_pair('c', 1));
  var.insert(make_pair('d', 6));
  var.insert(make_pair('e', 10));

  Expression* expression = analyse(expStr);

  int result = expression->interpreter(var);

  cout << result << endl;

  release(expression);

  return 0;
}

Boolan微专业-设计模式（Week03）

内容概要

对象性能

状态变化

数据结构

行为变化

领域规则

五、对象性能

14.Singleton 单件模式

15.Flyweight 享元模式

六、状态变化

16.State 状态模式

17.Mmento 备忘录

七、数据结构

18.Composite 组合模式

19.Iterator 迭代器

20.Chain of Resposibility 职责链

八、行为变化

21.Command 命令模式

22.Visitor 访问器

九、领域模式

23. Interpreter 解析器

猜你喜欢

热点阅读