说说设计模式

作者: Realizability | 来源:发表于2016-05-01 20:17 被阅读0次

说说设计模式
游戏开发中的MVVM设计模式
GeekBand 设计模式笔记&心得第一周（1）设计原则
Java面试设计模式
2020顺F面经
c++学习记录10（GeekBand）
js中的继承
说说迭代器设计模式
java面试&数据存储系列
浅谈设计模式-2

这几天从图书馆借了借来了《设计模式》，花了几个小时大致浏览了一下。当然了，在此之前我已经拜读过王垠的文章。我的观点和他基本相同，不过既然是要谈谈还是详细点说吧。

创建型模式，简单点解释，就是根据输入创建不同的子类。唯一值得一提的是单例模式（Singleton pattern）。

结构型模式，说的就是接口的设计。其实道理很简单，尽量少暴露类型内部的实现，让接口保持功能简洁实用，包括一些行为模式也是这个道理。

行为模式倒是有几个值得稍微细说。

职责链模式（Chain of responsibility）：每个子类都有一个后继，如果当前子类的功能无法处理得到的输入，则将输入传给其后继，直到链的尾部。说白了就是一个链表而已，当然了1994年数据结构并不如今天这么普及。如果换成其他数据结构例如函数数组效率会更高。

迭代器模式（Iterator）：如今的各种语言标准库里的类型如链表，哈希表，红黑树，数组，字符串都是体现。如C++/STL里的Iterator，C#里的IEnumerable/IEnumerator。

观察者模式（Observer）：将消息订阅者（Subscriber）统一放入一个列表中，事件发生后将消息传递给列表中的所有函数，处理该消息。C#中的委托链就是这么个东西。

策略模式（Strategy）：就是把一个函数当作参数传入另一个函数，书中的做法是将一个对象传入函数，再调用对象中的函数。不过如今各种语言里头lambda到处都是，书中的做法已经过时。关于这点，可以多说几句，创建型模式中的很多做法以及命令模式（Command）其实都是输入消息=>函数处理的映射。然而很多时候我们可以直接传入需要处理的函数，甚至都省去了传入消息和映射的步骤。

解释器模式（Interpreter）：就是写一个解释器，往简单了说不就是树的遍历？当然了不同解释器写起来难度千差万别，哪里是一个pattern就能说的了的？

访问者模式（Visitor）：全书中唯一有技术含量的部分。因为面向对象语言中没有模式匹配，所以被迫用visitor pattern来达到multiple dispatch的目的。

以下是《C++思想》中multiple dispatch的实现：

using namespace std;
class Paper;
class Scissors;
class Rock;
enum Outcome { win, lose, draw };

ostream& operator<<(ostream& os, constOutcome out) {
   switch(out) {
     casewin: return os << "win";
     caselose: return os << "lose";
     casedraw: return os << "draw";
 }
}

class Item {
public:
 virtual Outcome compete(const Item*) = 0;
 virtual Outcome eval(const Paper*) const = 0;
 virtual Outcome eval(const Scissors*) const=0;
 virtual Outcome eval(const Rock*) const = 0;
 virtual ostream& print(ostream& os)const = 0;
 virtual ~Item() {}
 friend ostream& operator<<(ostream& os, const Item*it) {
   return it->print(os);
 }
};

class Paper : public Item {
public:
 Outcome compete(const Item* it) {
   return it->eval(this);
 }
 Outcome eval(const Paper*) const {
   return draw;
 }
 Outcome eval(const Scissors*) const {
   return win;
 }
 Outcome eval(const Rock*) const {
   return lose;
 }
 ostream& print(ostream& os) const {
   return os << "Paper ";
 }
};

class Scissors : public Item {
public:
 Outcome compete(const Item* it) {
   return it->eval(this);
 }

 Outcome eval(const Paper*) const {
   return lose;
 }

 Outcome eval(const Scissors*) const {
   return draw;
 }

Outcome eval(const Rock*) const {
   return win;
 }

 ostream& print(ostream& os) const {
   return os << "Scissors";
 }
};
class Rock : public Item {
public:
 Outcome compete(const Item* it) {
   return it->eval(this);
 }

 Outcome eval(const Paper*) const {
   return win;
 }
 Outcome eval(const Scissors*) const {
   return lose;
 }

 Outcome eval(const Rock*) const {
   return draw;
 }

 ostream& print(ostream& os) const {
   return os << "Rock ";
 }
};

struct Compete {

 Outcome operator()(Item* a, Item* b) {
   cout<< a << "\t" << b << "\t";
   return a->compete(b);
 }
}; 

 如果使用visitor pattern代码如下：


using namespace std;
class Paper;
class Scissors;
class Rock;
enum Outcome { win, lose, draw };
ostream&
operator<<(ostream& os, constOutcome out) {
 switch(out) {
 default:
 casewin: return os << "win";
 caselose: return os << "lose";
 casedraw: return os << "draw";
 }
}

class Item {
public:
 virtual Outcome compete(const Item*) = 0;
 virtual ostream& print(ostream& os)const = 0;
 virtual ~Item() {}
 friend ostream&
 operator<<(ostream& os, const Item*it) {
   return it->print(os);
 }
};

class Visitor{
public:
 virtualOutcome evalPaper () const = 0;
 virtual Outcome evalScissors () const= 0;
 virtual Outcome evalRock() const = 0;
 virtual~Visitor () {
};


class Paper : public Item, public Visitor {
public:
 Outcome compete(const Visitor* it) {
   return it->evalPaper();
 }

 Outcome evalPaper() const {
   return draw;
 }

 Outcome evalScissors() const {
   return win;
 }

 Outcome evalRock() const {
   return lose;
 }

 ostream& print(ostream& os) const {
   return os << "Paper ";
 }
};


class Scissors : public Item , public Visitor {
public:
 Outcome compete(const Visitor* it) {
   return it->evalScissors();
 }

 Outcome evalPaper () const {
   return lose;
 }

 Outcome evalScissors() const {
   return draw;
 }

Outcome evalRock() const {
 return win;
 }

 ostream& print(ostream& os) const {
   return os << "Scissors";
 }
};

class Rock : public Item , public Visitor {
public:
 Outcome compete(const Visitor* it) {
   return it->evalRock();
 }
 Outcome evalPaper () const {
   return win;
 }

 Outcome evalScissors() const {
   return lose;
 }
 Outcome evalRock() const {
   return draw;
 }
 ostream& print(ostream& os) const {
   return os << "Rock ";
 }
};
struct Compete {
 Outcome operator()(Item* a, Item* b) {
  cout << a << "\t"<< b << "\t";
 return a->compete(b);
 }
};

本例中特别之处在于同一类型互为访问者和接受者，通常访问者模式被用于解释器的使用中，接受者即为抽象语法树，访问者则提供解释方法，这样同一个语法树可以接受不同的解释方法。