C++设计模式笔记
设计模式
如何解决复杂性？
分解
核心思想：分而治之，将大问题分解为多个小问题，将复杂问题分解为多个简单的问题。
抽象
核心思想：从高层次角度讲，人们处理复杂性有一个通用的技术，及抽象。由于不能掌握全部的复杂对象，选择护士他的非本质细节，而去处理泛化和理想化的对象模型。
总结来说就是，复用最好的代码就是复用性高。
面向对象设计原则
对象的概念：
- 从语言实现层面来看，对象封装了代码和数据。
- 从规格层面讲，对象是一系列可被使用的公共接口。
- 从概念层面讲，对象时某种拥有责任的抽象。
设计原则
依赖倒置原则（DIP）：
- 高层模块（稳定）不应该依赖于低层模块（变化）二者都应该依赖于抽象（稳定）。
- 抽象（稳定）不应该依赖于实现细节（变化），实现细节应该依赖于抽象（稳定）。
开放封闭原则（OCP）：
- 对扩展开放，对更改封闭。
- 类模块应该是可扩展的，但是不可修改。
单一职责原则（SRP）：
- 一个类应该仅有一个引起它变化的原则。
- 变化的方向隐含着类的责任。
Liskov替换原则（LSP）：
- 子类必须能够替换他们的基类。
- 继承表达类型抽象
接口隔离原则（ISP）：
- 不应该强迫客户程序依赖他们不用的方法。
- 接口应该小而完备。
优先使用对象组合，而不是类继承
- 类继承通常为“白箱复用”，对象组合通常为“黑箱复用”。
- 继承在某种程度上破坏了封装性，子类父类耦合度很高。
- 而对象组合则只要求被组合的对象具有良好定义的接口，耦合度低。
封装变化点：
- 使用封装来创建对象之间的分界层，让设计者可以在分界层的一侧进行修改，而不会对另一侧产生不良影响，从而实现层次间的松耦合。
针对接口与编码，而不是针对实现编程：产业强盛的标志
- 不将变量类型声明为某个特定的具体类，而是声明为某个接口
- 客户程序无需获知对象的具优类型，只需要知道对象所具有的接口。
- 减少系统中各部分的依赖关系从而实现“高内聚、松耦合’的类型设计方案。
GOF-23模式分类
从目的来看：
- 创建型模式：将对象的部分创建工作延迟到子类或者其他对象，从而应对需求变化为对象创建时具体类型实现引来的冲击。
- 结构型模式：通过类继承或者对象组合获得更灵活的结构，从而应对需求变化为对象的结构带来的冲击。
- 行为型模式：通过类继承或者对象组合来划分类与对象间的职责，从而应对需求变化为多个交互的对象带来的冲击。
从范围来看：
- 类模式处理类与子类的静态关系。
- 对象模式处理对象间的动态关系。
C++设计模式
工厂模式
工厂模式：主要是封装了对象的创建。
简单工厂(Simple Factory)：
优点：
- 把对象的创建封装在一个接口函数里面，通过传入不同的标识，返回创建的对象。
- 使用者不需要自己负责new对象，不用了解对象创建的详细过程。
缺点：
- 提供创建对象实例的接口函数不闭合，不能对修改关闭。
工厂方法(Factory Method)：
优点：
- 使用Factory基类，提供一个纯虚函数（创建产品），定义派生类（具体产品的工厂）负责创建对应的产品，可以做到不同的产品在不同的工厂进行创建。能对现有工厂以及产品的修改关闭
缺点：
- 忽略了产品之间的关联关系，属于一个产品簇的不应该放到不同的工厂里面去创建。不符合产品对象创建逻辑；
- 工厂类太多，难以维护。
抽象工厂(Abstact Factory)
优点：
- 把现有关联关系、属于同一个产品簇的所有产品创建的接口函数放在一个抽象工厂里面，派生类（具体产品的工厂）应该负责创建该产品簇里面的所有产品。
这里使用了一个汽车生产的工厂示例，列举了简单工厂和工厂方法，并使用智能指针进行对象空间优化回收。
简单工厂和工厂方法
#include p1=new BMW("X1");是错误的
// 最原始的对象产生
unique_ptr<Car> p1(new BMW("X1"));
unique_ptr<Car> p2(new Audi("A6"));
// 简单工厂
// unique_ptr factory(new SimpleFactory());
// unique_ptr p1(factory->createCar(bmw));
// unique_ptr p2(factory->createCar(audi));
// 工厂方法
// unique_ptr bmwFactory(new BMWFactory);
// unique_ptr audiFactory(new AudiFactory);
// unique_ptr p1(bmwFactory->createCar("X6"));
// unique_ptr p2(audiFactory->createCar("A8"));
p1->show();
p2->show();
return 0;
}
抽象工厂方法
上一节中的工厂方法会存在一个问题，在定义了一个Factory抽象类后，每一个类将对应一个类的工厂，如BWM->BMWFactory，Audi->AudiFactory，这样会导致一个问题，在生产一类产品时，如手机充电器和充电线，那么就又需要两个工厂来实现，所以这样就会导致工厂冗余。所以，提出了抽象工厂来解决这个问题，这里以汽车的生产部件为例进行说明：
#include 代理模式
代理（proxy）模式：通过代理类，来控制实际对象的访问权限。其实也就是定义一个虚基类，子类继承虚基类实现不同级别对象的实现，可以看以下类似代码：
#include p1(new FreeVideoSiteProxy());
unique_ptr<VideoSite> p1(new VipVideoSiteProxy());
p1->freeMovie();
p1->vipMovie();
p1->ticketMovie();
return 0;
}
观察者模式
行为型模式：主要关注的是对象之间的通信。
以观察者-监听者模式（发布-订阅模式）设计模式：主要关注的是对象的一对多的关系，也就是多个对象都依赖一个对象，当该对象的状态发生改变时，其他对象都能够结束到相应的通知。
ps：一组数据改变（数据对象）->通过这一组数据->曲线图（对象1）/柱状图（对象2）/圆饼图（对象3）。当数据对象改变时，对象1、对象2、对象3应该及时的收到相应的通知。
#include
#include olist;
olist.push_back(obser);
_submap.insert(make_pair(msgid, olist));
}
*/
}
// 主题检测发生改变，通知相应的观察者对象处理事件
void dispatch(int msg)
{
auto it = _submap.find(msg);
if (it != _submap.end())
{
for(Observer* pObser:it->second)
{
pObser->handle(msg);
}
}
}
private:
unordered_map<int, list<Observer *>> _submap;
};
int main()
{
Subjects sub;
Observer *p1 = new Observer1();
Observer *p2 = new Observer2();
Observer *p3 = new Observer3();
sub.addObserver(p1, 1);
sub.addObserver(p2, 3);
sub.addObserver(p3, 1);
sub.addObserver(p3, 2);
sub.addObserver(p1, 3);
sub.dispatch(2);
return 0;
}
适配器模式
适配器模式：让不兼容的接口可以在一起工作。
下方使用C++实现了一个电脑播放投影视频的例子，电脑仅仅支持VGA接口，如何实现HDMI接口转化成VGA来适配电脑使用。也就是如何实现一个VGA和HEMI类的转化接口。
#include 装饰器模式
装饰器（decorate）模式和代理模式类似。代理模式也就是定义委托类和代理类继承抽象类，并重写函数方法，通过在代理类中使用委托类的对象调用不同级别代理的方法访问。
装饰器主要是增加现有类的功能，但是添加现有类的一个方法还有一个方法，就是新建一个子类。如果每次新建一个功能都需要新建一个子类的话，那么代码中就会有很多的子类被添加进来。
以下实现了一个汽车装饰类的代码实现：
#include 单例模式
常见的类创建一个对象，便会得到一个新的对象。而单例模式则有些不同。
单例模式：一个类不管创建多少次对象，永远只能得到该类型一个对象的实例。可以查看C++实现MySQL数据库连接池中的线程池获取代码，将线程池定义为静态成员方法和静态成员变量，导致其处于静态变量区，只需要初始化一次。类似的日志模块应该也可以使用单例模式。
饿汉式单例模式：还没有获取实例对象，实例对象就已经产生了。
懒汉式单例模式：唯一的实例对象，直到第一次获取它的时候才产生。
下面介绍了两种单例模式的代码设计，其中提供了两种懒汉式单例模式的示例：
#include 一般情况下第二种懒汉式单例模式用的比较多，也更简单，在静态成员方法中定义静态成员对象。