设计模式是软件设计中常见问题的典型解决方案。每个模式就像一张蓝图，可以通过对其进行定制来解决代码中的特定设计问题。
创建型
单例模式
单例模式保证一个类只有一个全局共享的实例，并提供一个访问该实例的全局 API。
所有单例的实现都包含以下两个相同的步骤：
- 将默认构造函数设为私有，防止其他对象在某些地方进行单例类的构造；
- 使用静态构建方法创建对象，并将其保存在一个静态成员变量中。此后所有对于该函数的调用都将返回这一对象；
懒汉式(lazy)
用到的时候才创建实例。C++11 以前容易产生线程安全的问题，但 C++11 标准之后的最佳的选择是「Meyers’ Singleton」，它利用了局部静态变量在第一次使用时才初始化的特性。并且由于 C++11 标准解决了局部静态变量的线程安全问题，使得它成为当前最优雅的实现方式。
1class Singleton {
2 public:
3 static Singleton& getInstance() {
4 static Singleton instance; // so elegent
5 return instance;
6 }
7
8 private:
9 Singleton() = default;
10 ~Singleton() = default;
11 Singleton(const Singleton&) = default;
12 Singleton& operator=(const Singleton&) = default;
13};
饿汉式(eager)
指单例实例在程序运行时被立即执行初始化，也能保证线程安全。但如果用不到的话可能会浪费不必要的资源，同时如果一个单例依赖另一个单例，此时这两个单例的构造先后顺序是不确定的，存在隐患。
推荐用 Meyers’ Singleton。
1class Singleton {
2 public:
3 static Singleton* getInstance() { return instance; }
4
5 private:
6 Singleton() = default;
7 ~Singleton() = default;
8 Singleton(const Singleton&) = default;
9 Singleton& operator=(const Singleton&) = default;
10
11 static Singleton* instance;
12};
13
14Singleton* Singleton::instance = new Singleton();
工厂模式
工厂模式通过使用一个全局共享的接口来创建新的对象。终极目的是为了解耦，实现创建者和调用者的分离。
它利用了面向对象中多态的特性，将存在着继承关系的类，通过一个工厂类创建对应的派生类对象。
简单工厂
简单工厂的工厂类里封装了创建具体产品对象的函数。
1enum class ProductType {
2 TYPEA,
3 TYPEB
4};
5class Factory {
6 public:
7 Product* CreateProduct(ProductType type) {
8 switch (type) {
9 case ProductType::TYPEA:
10 return new ProductA();
11 case ProductType::TYPEB:
12 return new ProductB();
13 ...
14 default:
15 return nullptr;
16 }
17 }
18};
缺陷在于扩展性差：一旦需要新增产品，则必须修改 ProductType 以及工厂类的创建函数。
工厂方法
工厂方法将工厂类进行抽象，仅提供创建具体产品的接口，而具体实现交由子类（即具体工厂）去完成。
1class AbstractFactory {
2 public:
3 virtual Product* CreateProduct() = 0;
4 virtual ~AbstractFactory() = default;
5};
6
7class ConcreteFactory1 : public AbstractFactory {
8 public:
9 virtual Product* CreateProductA() { return new ProductA(); }
10};
11
12class ConcreteFactory2 : public AbstractFactory {
13 public:
14 virtual Product* CreateProductB() { return new ProductB(); }
15};
16...
同样，每新增一个产品，就需要增加一个对应的产品的具体工厂类。相比简单工厂而言，工厂方法模式需要更多的类定义。
抽象工厂
在工厂方法基础上，为抽象类增加多个接口，若子类支持某接口，则进行 override，否则什么也不做。这样就实现了创建多个产品族中的产品对象。代码略。
模板工厂
以上三种方式，在新增产品时，要么修改工厂类，要么需新增具体的工厂类，说明工厂类的封装性还不够好。模板工厂是将工厂方法模式封装成模板工厂类，那么这样在新增产品时，是不需要新增具体的工厂类，减少了代码的编写量。
1// 抽象模板工厂类
2// AbstractProduct_t 产品抽象类
3template <class AbstractProduct_t>
4class AbstractFactory {
5 public:
6 virtual AbstractProduct_t* CreateProduct() = 0;
7 virtual ~AbstractFactory() = default;
8};
9
10// 具体模板工厂类
11// AbstractProduct_t 产品抽象类，ConcreteProduct_t 产品具体类
12template <class AbstractProduct_t, class ConcreteProduct_t>
13class ConcreteFactory : public AbstractFactory<AbstractProduct_t> {
14 public:
15 AbstractProduct_t* CreateProduct() { return new ConcreteProduct_t(); }
16};
当然，也可以在创建产品时通过某种 primary key 将其注册进 std::map/std::unordered_map 中，后续可以通过该 key 直接获取之前创建过的产品，这就实现了「反射」。
行为型
状态模式 & 策略模式
使用状态模式的类需要在内部设置一个「状态变量」，该变量会随函数调用而被动切换，类似于自动状态机，并且根据不同状态执行不同的行为。
而使用策略模式的类需要在内部设置一个「策略变量」，该变量会被开发者手动设置，从而根据不同策略执行不同的行为。
不难发现，这两种模式都涉及将具体的行为封装到不同的类中，以便在运行时选择不同的行为，但区别在于是被动修改还是主动修改。更严格地说，切换这一内部变量的函数是 private 的还是 public 的。
通常会搭配单例模式实现，因为特定行为应当是全局一致的。
1/**
2 * 这段代码可以通过声明与实现分离的形式编写，这里就简单写到一起了。
3 */
4#include <iostream>
5
6class StateBase;
7class Object {
8 public:
9 Object();
10 void request();
11
12 private:
13 void setState(const StateBase* newState) { state = newState; }
14 const StateBase* state;
15};
16
17class StateBase {
18 public:
19 virtual void handle(Object* obj) const = 0;
20 virtual ~StateBase() = default;
21};
22
23class StateA : public StateBase {
24 public:
25 void handle(Object* obj) const override;
26 static const StateA& get() {
27 static const StateA state;
28 return state;
29 }
30};
31
32class StateB : public StateBase {
33 public:
34 void handle(Object* obj) const override;
35 static const StateB& get() {
36 static const StateB state;
37 return state;
38 }
39};
40
41void StateA::handle(Object* obj) const {
42 std::cout << "here is stateA" << std::endl;
43 obj->setState(&StateB::get()); // 状态转移到 stateB
44}
45
46void StateB::handle(Object* obj) const {
47 std::cout << "here is stateB" << std::endl;
48 obj->setState(&StateA::get()); // 状态转移到 stateA
49}
50
51Object::Object() : state(&StateA::get()) {}
52void Object::request() { state->handle(this); } // 利用多态，根据不同状态执行不同行为
53
54int main() {
55 Object obj;
56 obj.request(); // here is stateA
57 obj.request(); // here is stateB
58 return 0;
59}
1/**
2 * 这段代码可以通过声明与实现分离的形式编写，这里就简单写到一起了。
3 */
4#include <iostream>
5
6class StrategyBase;
7class Object {
8 public:
9 Object();
10 void setStrategy(const StrategyBase* newStrategy) { strategy = newStrategy; }
11 void execute();
12
13 private:
14 const StrategyBase* strategy;
15};
16
17class StrategyBase {
18 public:
19 virtual void handle(Object* obj) const = 0;
20 virtual ~StrategyBase() = default;
21};
22
23class StrategyA : public StrategyBase {
24 public:
25 void handle(Object* obj) const override {
26 std::cout << "here is strategyA" << std::endl;
27 }
28 static const StrategyA& get() {
29 static const StrategyA strategy;
30 return strategy;
31 }
32};
33
34class StrategyB : public StrategyBase {
35 public:
36 void handle(Object* obj) const override {
37 std::cout << "here is strategyB" << std::endl;
38 }
39 static const StrategyB& get() {
40 static const StrategyB strategy;
41 return strategy;
42 }
43};
44
45void Object::execute() { strategy->handle(this); }
46
47int main() {
48 Object obj;
49 obj.setStrategy(&StrategyA::get()); // 主动切换策略到 StrategyA
50 obj.execute(); // here is strategyA
51
52 obj.setStrategy(&StrategyB::get()); // 主动切换策略到 StrategyB
53 obj.execute(); // here is strategyB
54 return 0;
55}
命令模式
命令模式可将请求转换为一个包含与请求相关的所有信息的独立对象，这允许用户根据不同的请求将方法参数化、延迟请求执行或将其放入队列中，同时支持「撤销」操作。
1#include <iostream>
2#include <queue>
3#include <string>
4
5class Dummy {
6 public:
7 void handle(const std::string &a) { std::cout << "Dummy: (" << a << ".)\n"; }
8};
9
10class Command {
11 public:
12 virtual ~Command() {}
13 virtual void execute() const = 0;
14};
15
16// 简单命令的执行不和其它对象交互
17class SimpleCommand : public Command {
18 public:
19 explicit SimpleCommand(const std::string &s) : str(s) {}
20 void execute() const override {
21 std::cout << "SimpleCommand: (" << str << ")\n";
22 }
23
24 private:
25 std::string str;
26};
27
28// 复杂命令的执行可能会需要其他对象参与
29class ComplexCommand : public Command {
30 public:
31 ComplexCommand(Dummy *d, const std::string &a, const std::string &b)
32 : dummy(d), strA(a), strB(b) {}
33 void execute() const override {
34 dummy->handle(this->strA);
35 dummy->handle(this->strB);
36 }
37
38 private:
39 Dummy *dummy;
40 std::string strA;
41 std::string strB;
42};
43
44// 请求发起者 与 命令执行者 的中间层，用于存储命令
45class Invoker {
46 public:
47 ~Invoker() {
48 while (!cmdQ.empty()) {
49 delete cmdQ.front();
50 cmdQ.pop();
51 }
52 }
53
54 void addCmd(Command *command) { cmdQ.push(command); }
55 void invoke() {
56 while (!cmdQ.empty()) {
57 cmdQ.front()->execute();
58 delete cmdQ.front();
59 cmdQ.pop();
60 }
61 }
62
63 private:
64 std::queue<Command *> cmdQ;
65};
66
67int main() {
68 Invoker *invoker = new Invoker;
69 Dummy *dummy = new Dummy;
70 invoker->addCmd(new SimpleCommand("Hi"));
71 invoker->addCmd(new ComplexCommand(dummy, "Hello", "World"));
72 invoker->invoke();
73
74 delete invoker;
75 delete dummy;
76
77 return 0;
78}
这里没有实现「撤销」操作，如果需要的话，可以将
Invoker类中的命令队列改为双向链表，并用指针指向当前命令，从而支持撤销（当前命令执行cancel()，指针前移）与重做（指针后移，并令当前命令执行execute()）操作。
不难发现，命令模式的优越性在于，将「请求进行一个操作的对象」，和「知道如何执行该操作的对象」进行解耦，同时可以很方便地对命令类型进行扩展。
观察者模式
观察者模式允许用户定义一种「订阅」机制，可在某一事件发生时通知多个订阅该类型事件的其他对象。拥有一些值得关注的状态的对象通常被称为「目标」，由于它要将自身的状态改变通知给其他对象，我们也将其称为发布者(publisher)，所有希望关注发布者状态变化的其他对象被称为订阅者(subscriber)。
我们可以在发布者类中实现两个机制：
- 一个存储订阅者对象引用的列表成员变量
subscribers； - 一些用于添加或删除该列表中订阅者的公有方法（如
subscribe()与unsubscribe()）；
这样，一旦发布者类有事件发生，就可以通过遍历 subscribers 的方式通知所有订阅者。
1#include <iostream>
2#include <list>
3#include <string>
4
5class SubscriberBase {
6 public:
7 virtual ~SubscriberBase() = default;
8 virtual void update(const std::string &message_from_Publisher) = 0;
9};
10
11class PublisherBase {
12 public:
13 virtual ~PublisherBase() = default;
14 virtual void subscribe(SubscriberBase *Subscriber) = 0;
15 virtual void unsubscribe(SubscriberBase *Subscriber) = 0;
16 virtual void notify(const std::string &str) = 0;
17};
18
19class Publisher : public PublisherBase {
20 public:
21 void subscribe(SubscriberBase *Subscriber) override {
22 subscribers.push_back(Subscriber);
23 }
24
25 void unsubscribe(SubscriberBase *Subscriber) override {
26 subscribers.remove(Subscriber);
27 }
28
29 void notify(const std::string &message) override {
30 for (auto subscriber : subscribers) {
31 subscriber->update(message);
32 }
33 }
34
35 private:
36 std::list<SubscriberBase *> subscribers;
37};
38
39class Subscriber : public SubscriberBase {
40 public:
41 Subscriber(Publisher *publisher) { publisher->subscribe(this); }
42
43 void update(const std::string &message) override { std::cout << message; }
44
45 void subscribe(Publisher *publisher) { publisher->subscribe(this); }
46 void unsubscribe(Publisher *publisher) { publisher->unsubscribe(this); }
47};
48
49int main() {
50 Publisher Publisher;
51 Subscriber Subscriber1(&Publisher);
52 Subscriber Subscriber2(&Publisher);
53
54 Publisher.notify("Hello World! :D");
55 Subscriber2.unsubscribe(&Publisher);
56
57 Publisher.notify("The weather is hot today! :p");
58 Subscriber1.unsubscribe(&Publisher);
59
60 return 0;
61}
这种机制还可以进一步扩展。比如我们可以为事件设置不同类型，允许订阅者关注不同类型的事件，这样就可以根据事件类型通知特定的订阅者。