文章目录
一、单例模式
一个类不管常见多少次对象，永远只能得到该类型一个对象的实例
// p1、p2、p3指向同一对象
A* p1 = new A();
A* p2 = new A();
A* p3 = new A();
饿汉式单例模式： 还没有获取实例对象，实例对象就已经产生了
优点：线程安全。对象存放在数据段，main函数还没有开始执行，对象就已经初始化好了，一定是线程安全的。
缺点： 获取在软件启动的时候，并没有使用到这个对象，然而这个对象已经产生，这就比较浪费资源。
我们要限制类对象的个数，就要限制构造对象的方法，即构造函数。不能让外界随意访问我们的构造函数，所以我们需要构造函数私有化，调用构造函数的必须是用户调用的某个接口，我们把接口写好，就能控制外界访问构造函数的方式。
单例模式的核心是构造方法的私有化（即在入口处限制了对象的实例化），之后在类的内部实例化对象，并通过静态方法返回实例化对象的引用
#include<iostream>
using namespace std;
class Singleton {
public:
// 由于普通成员方法的调用依赖对象，而获取唯一对象的时候并没有产生对象，所以定义成static
// static接口获取指向对象的指针
static Singleton* getInstance() {
return &instance;
}
private:
// 定义一个唯一的实例对象(数据段)
// 由于是类Singleton内再写一个Singleton，这里被编译器处理成instance的类型声明，而非instance的定义，所以需要在类外初始化
static Singleton instance;
// 构造函数私有化
Singleton() {
}
// delete拷贝构造和赋值重载
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
};
// 类外初始化static成员变量处于数据段，对象在函数执行前就存在，运行到的时候才初始化
Singleton Singleton::instance;
int main(){
Singleton* p1 = Singleton::getInstance();
Singleton* p2 = Singleton::getInstance();
Singleton* p3 = Singleton::getInstance();
cout << p1 << endl;
cout << p2 << endl;
cout << p3 << endl;
return 0;
}
为什么获取唯一的实例对象的getInstance要定义成static？
由于普通成员方法的调用依赖对象，而获取唯一对象的时候并没有产生对象，所以定义成static
为什么唯一的实例对象是static？
存放在数据段，不占用对象空间。如果不写成static，会引起类的循环定义。
懒汉式单例模式（多用）： 唯一的实例对象是在第一次获取的时候才产生
class Singleton {
public:
static Singleton* getInstance() {
if (instance == nullptr) {
instance = new Singleton();// 堆区
}
return instance;
}
private:
// 定义一个唯一的实例对象的指针（数据段）
static Singleton* volatile instance;
Singleton() {}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
};
Singleton* volatile Singleton::instance = nullptr;getInstance是否是可重入函数（非递归环境下）？
可重入函数： 主要用于多任务环境中，一个可重入的函数简单来说就是可以被中断的函数，也就是说，可以在这个函数执行的任何时刻中断它，转入OS调度下去执行另外一段代码，而返回控制时不会出现什么错误；而不可重入的函数由于使用了一些系统资源，比如全局变量区，中断向量表等，所以它如果被中断的话，可能会出现问题，这类函数是不能运行在多任务环境下的
instance = new Singleton()被拆解为：开辟内存、构造对象、给instance赋值。只要还没给instance赋值，if条件满足，另一线程就可以进入if语句，线程不安全，不是可重入函数。
通过 锁 + 双重判断 的方法，改为线程安全的函数
static Singleton* getInstance() {
if (instance == nullptr) {
unique_lock<mutex> lock(mtx);
if (instance == nullptr) {
instance = new Singleton();// 堆区
}
}
return instance;
}instance指针属于数据段，是同一进程多个进程共享的内存。
为了加快指令的执行，CPU会把共享内存的值拷贝一份带到各个线程的缓存，这依然导致线程不安全，所以加上volatile，使得各个线程不再持有缓存
更为简洁的线程安全写法
class Singleton {
public:
static Singleton* getInstance() {
// 函数局部静态变量的初始化，在汇编指令上已经自动添加线程互斥的指令
static Singleton instance;
return &instance;
}
private:
Singleton() {
}
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
};二、简单工厂 Simple Factory
简单工厂（Simple Factory）不属于标准的OOP设计模式中的一项，在C++项目里会出现很多类，每次创建对象的时候，都需要通过new 类名称的方式来生成对象，用户需要记忆很多类的名称，这样的设计使得代码很难维护，类名如果做了改变，那么所有使用类名称的地方都需要去修改，耦合性太强，Simple Factory就此诞生的。
#include<iostream>
#include<string>
#include<memory>
using namespace std;
class Car {
public:
Car(string name) :_name(name) {
}
// 纯虚函数
virtual void show() = 0;
string _name;
};
class Bmw : public Car {
public:
Bmw(string name) : Car(name) {
}
void show() {
cout << "获取一辆BMW " <<_name<< endl;
}
};
class Benz : public Car {
public:
Benz(string name) : Car(name) {
}
void show() {
cout << "获取一辆Benz " << _name << endl;
}
};
enum CarType {
BMW,
BENZ
};
class SimpleFactory {
public:
Car* create_car(CarType ct) {
switch (ct) {
case BMW:
return new Bmw("X5");
case BENZ:
return new Benz("A6");
default:
cerr << "参数有误" << endl;
break;
}
return nullptr;
}
};
int main(){
unique_ptr<SimpleFactory> factory(new SimpleFactory());
unique_ptr<Car> p1(factory->create_car(BMW));
unique_ptr<Car> p2(factory->create_car(BENZ));
p1->show();
p2->show();
return 0;
}
create_car函数无法做到 “开-闭”原则 ，即对原有代码修改关闭，对功能扩展开放。这个函数随着新对象的添加，或者原有对象的删除，都会导致该函数的代码修改，而且有可能影响原来的功能。
三、工厂方法 Factory Method
工厂方法为每种产品都提供了相应的实例工厂，当增加新的汽车工厂时，只需要增加对应工厂类即可，删除汽车工厂时，则只需要删除工厂类。
可解决简单工厂不符合 “开-闭”原则 的问题。
class Benz : public Car {
public:
Benz(string name) : Car(name) {
}
void show() {
cout << "获取一辆Benz " << _name << endl;
}
};
class Factory {
public:
// 工厂方法
virtual Car* create_car(string name) = 0;
};
// 宝马工厂
class BmwFactory : Factory{
public:
Car* create_car(string name) {
return new Bmw(name);
}
};
// 奔驰工厂
class BenzFactory : Factory {
public:
Car* create_car(string name) {
return new Benz(name);
}
};增加main函数
int main(){
// 创建工厂
unique_ptr<BmwFactory> bmw_factory(new BmwFactory());
unique_ptr<BenzFactory> benz_factory(new BenzFactory());
// 给型号即可拿到车，无需手动new创建
unique_ptr<Car> p1(bmw_factory->create_car("X5"));
unique_ptr<Car> p2(benz_factory->create_car("A6"));
p1->show();
p2->show();
return 0;
}缺点： 每一个实例工厂负责生产一种实例产品，也就是一个产品对应一个工厂，一个工厂对应一个产品。在现实生活中一个工厂是可以生产多种产品的，而工厂方法中，给这每一个产品都创建一个工厂类，这样代码中的类就太多了，不好维护。
四、抽象工厂 Abstract Factory
抽象工厂用于生产有关联关系的系列产品
车产品类
class Car {
public:
Car(string name) :_name(name) {
}
// 纯虚函数
virtual void show() = 0;
string _name;
};
class Bmw : public Car {
public:
Bmw(string name) : Car(name) {
}
void show() {
cout << "获取一辆BMW " <<_name<< endl;
}
};
class Benz : public Car {
public:
Benz(string name) : Car(name) {
}
void show() {
cout << "获取一辆Benz " << _name << endl;
}
};灯产品类
class Light {
public:
virtual void show() = 0;
};
class BmwLight : public Light{
public:
void show() {
cout << "得到一个BMW车灯" << endl;
}
};
class BenzLight : public Light {
public:
void show() {
cout << "得到一个Benz车灯" << endl;
}
};工厂类
抽象工厂：对有一组关联关系的产品簇提供统一创建
class AbstractFactory {
public:
// 工厂方法 创建汽车
virtual Car* create_car(string name) = 0;
// 工厂方法 创建车灯
virtual Light* create_car_light() = 0;
};
// 宝马工厂
class BmwFactory : public AbstractFactory {
public:
Car* create_car(string name) {
return new Bmw(name);
}
Light* create_car_light() {
return new BmwLight();
}
};
// 宝马工厂
class BenzFactory : public AbstractFactory {
public:
Car* create_car(string name) {
return new Benz(name);
}
Light* create_car_light() {
return new BenzLight();
}
};int main(){
// 创建抽象工厂，可生产有关联关系的一类产品
unique_ptr<AbstractFactory> bmw_factory(new BmwFactory());
unique_ptr<AbstractFactory> benz_factory(new BenzFactory());
unique_ptr<Car> c1(bmw_factory->create_car("X5"));
unique_ptr<Car> c2(benz_factory->create_car("A6"));
unique_ptr<Light> l1(bmw_factory->create_car_light());
unique_ptr<Light> l2(benz_factory->create_car_light());
c1->show();
c2->show();
l1->show();
l2->show();
return 0;
}简单工厂 Simple Factory
把对象的创建封装在一个接口函数里面，通过传入不同的标识，返回不同的对象。客户不用自己手动new对象，不用了解对象的创建过程。
提供创建对象实例的接口函数不闭合，不能对修改关闭
工厂方法 Factory Method
工厂基类，提供了纯虚函数用于提供创建产品的接口，派生类重写创建产品的接口。可以做到不同的产品在不同的工厂里创建，模块化清晰。
可以做到对现有工厂以及产品的修改关闭。
实际上，很多有关联关系的产品是放在同一工厂生产的。然而这种方法中，一种产品对应一个工厂，粒度太小，工厂类过多，维护困难。
抽象工厂 Abstract Factory
把有关联关系的产品放在一个抽象工厂内进行生产，派生类重写接口后实例化工厂，用于生产产品。
五、代理模式
最简单的作用就是对用户进行权限校验，然后访问委托类
委托类
class VideoSite {
public:
virtual void free_video() = 0;
virtual void vip_video() = 0;
virtual void ticket_video() = 0;
};
// 委托类
class FixBugVideoSite : public VideoSite {
public:
void free_video() {cout << "观看免费电影" << endl;}
void vip_video() {cout << "观看vip电影" << endl;}
void ticket_video() {cout << "观看用券电影" << endl;}
};代理类
// 用代理类进行权限控制
// 免费电影代理类
class FreeVideoSiteProxy : public VideoSite {
public:
FreeVideoSiteProxy() {
// 对对象进行代理
p_video = new FixBugVideoSite();
}
~FreeVideoSiteProxy(){delete p_video;}
void free_video() {p_video->free_video();}
void vip_video() {cout << "需要成为vip，才可观看vip电影" << endl;}
void ticket_video() {cout << "需要充值电影券，才可观看此电影" << endl;}
private:
VideoSite* p_video;
};
class VipVideoSiteProxy : public VideoSite {
public:
VipVideoSiteProxy() {
// 对对象进行代理
p_video = new FixBugVideoSite();
}
~VipVideoSiteProxy() {delete p_video;}
void free_video() {p_video->free_video();}
void vip_video() {p_video->vip_video();}
void ticket_video() {cout << "需要充值电影券，才可观看此电影" << endl;}
private:
// 基类指针访问派生类对象
VideoSite* p_video;
};
int main() {
// 免费代理类，多态：基类指针指向派生类对象
unique_ptr<VideoSite> p1(new FreeVideoSiteProxy());
p1->free_video();
p1->vip_video();
p1->ticket_video();
unique_ptr<VideoSite> p2(new VipVideoSiteProxy());
p2->free_video();
p2->vip_video();
p2->ticket_video();
return 0;
}六、装饰器模式 Decorator
可用于现有类的功能扩充
一般而言，我们扩充功能一般采用子类重写接口的方式，每个类都要添加代码，这样会导致添加过多的代码加入类
使用装饰器进行功能扩充
车类
// 抽象基类
class Car {
public:
virtual void show() = 0;
};
class BMW : public Car {
public:
void show() {
cout << "这是一辆宝马，有基本配置";
}
};
class Benz : public Car {
public:
void show() {
cout << "这是一辆奔驰，有基本配置";
}
};
装饰器类
// 装饰器的基类
class CarDecorator : public Car {
public:
// 对p进行装饰，Car*表示基类指针
CarDecorator(Car* p) :p_car(p){}
// 用基类指针保留装饰的对象
Car* p_car;
};
// 功能类1
class FunDecorator1 : public CarDecorator {
public:
FunDecorator1(Car* p): CarDecorator(p) {}
void show() {
p_car->show();
// 添加新功能
cout << "，自动刹车";
}
};
// 功能类2
class FunDecorator2 : public CarDecorator {
public:
FunDecorator2(Car* p) : CarDecorator(p) {}
void show() {
p_car->show();
// 添加新功能
cout << "，定速巡航";
}
};
装饰器使用
int main() {
// 由于FunDecorator1和FunDecorator2的构造函数接收的都是基类的指针类型
// 所以直接嵌套装饰
unique_ptr<Car> bmw(new FunDecorator2(new FunDecorator1(new BMW())));
bmw->show();
cout << endl;
unique_ptr<Car> benz(new FunDecorator2(new FunDecorator1(new Benz())));
benz->show();
cout << endl;
return 0;
}
/*
这是一辆宝马，有基本配置，自动刹车，定速巡航
这是一辆奔驰，有基本配置，自动刹车，定速巡航
*/七、适配器模式
class VGA {
public:
virtual void play() = 0;
};
// 只支持VGA接口的投影仪
class Projector_VGA : public VGA{
public:
void play() {
cout << "投影仪通过VGA接口进行视频播放" << endl;
}
};
// 只支持VGA接口的电脑
class Computer {
public:
void play_video(VGA* p_vga) {
cout << "电脑连接VGA接口的投影仪" << endl;
p_vga->play();
}
};
int main() {
Computer().play_video(new Projector_VGA());
return 0;
}
/*
电脑连接VGA接口的设备
投影仪通过VGA接口进行视频播放
*/现在有一批新的投影仪，这些投影仪只支持HDMI接口
class HDMI {
public:
virtual void play() = 0;
};
// 只支持VGA接口的投影仪
class Projector_HDMI : public HDMI {
public:
void play() {
cout << "投影仪通过HDMI接口进行视频播放" << endl;
}
};这时需要用只支持VGA的旧电脑连接HDMI接口的投影仪，就需要用得到适配器，这个适配器相当于一个转换头，把VGA信号转成HDMI信号
// 添加适配器，使得VGA接口的电脑和HDMI接口的投影仪一起工作
class VGAToHDMIAdapter : public VGA{
public:
VGAToHDMIAdapter(HDMI* p) :p_hdmi(p) {
}
// 重写VGA的play方法，用VGA的play封装HDMI的play（转换器方法）
void play() {
// 此处调用的是HDMI接口的
cout << "使用转换器将VGA信号转为HDMI信号" << endl;
p_hdmi->play();
}
private:
HDMI* p_hdmi;
};
int main() {
Computer().play_video(new VGAToHDMIAdapter(new Projector_HDMI()));
return 0;
}
八、观察者—监听者模式
也叫发布—订阅模式，主要关注的是对象一对多的关系。也就是多个对象依赖一个对象，当该对象状态发生变化时，其他对象也应该及时收到通知。
就好比有一个数据对象，一个折线图对象，一个柱状图对象，一个圆饼图对象。当数据对象发生变化时，其他三个对象都要发生相应的变化。
3个订阅者
class Observer {
public:
virtual void handle(int msg_id) = 0;
};
class Observer1 : public Observer {
public:
void handle(int msg_id) {
switch (msg_id) {
case 1:
cout << "Observer1 recv msg 1" << endl;
break;
case 2:
cout << "Observer1 recv msg 2" << endl;
break;
default:
cout << "Observer1 recv unknown msg" << endl;
break;
}
}
};
class Observer2 : public Observer {
public:
void handle(int msg_id) {
switch (msg_id) {
case 2:
cout << "Observer2 recv msg 2" << endl;
break;
default:
cout << "Observer2 recv unknown msg" << endl;
break;
}
}
};
class Observer3 : public Observer {
public:
void handle(int msg_id) {
switch (msg_id) {
case 1:
cout << "Observer3 recv msg 1" << endl;
break;
case 3:
cout << "Observer3 recv msg 3" << endl;
break;
default:
cout << "Observer3 recv unknown msg" << endl;
break;
}
}
};1个发布者
// 主题类
class Subject {
public:
void add_observer(int msg_id, Observer* observer) {
_sub_map[msg_id].push_back(observer);
/*
auto iter = _sub_map.find(msg_id);
if (iter != _sub_map.end()) {
iter->second.push_back(observer);
}
else {
list<Observer*> li;
li.push_back(observer);
_sub_map.insert({ msg_id, li });
}*/
}
// 通知对msg_id感兴趣的观察者处理该事件
void dispatch(int msg_id) {
auto iter = _sub_map.find(msg_id);
if (iter != _sub_map.end()) {
for (Observer* obser : iter->second) {
obser->handle(msg_id);
}
}
}
private:
// 存放对事件感兴趣的观察者们
unordered_map<int, list<Observer*>> _sub_map;
};
测试代码
int main() {
Subject subject;
Observer* obser1 = new Observer1();
Observer* obser2 = new Observer2();
Observer* obser3 = new Observer3();
// 给订阅者添加对指定事件感兴趣的观察者
subject.add_observer(1, obser1);
subject.add_observer(2, obser1);
subject.add_observer(2, obser2);
subject.add_observer(1, obser3);
subject.add_observer(3, obser3);
int msg_id;
while (true) {
cout << "输入消息类型：";
cin >> msg_id;
if (msg_id == -1) {
break;
}
subject.dispatch(msg_id);
}
return 0;
}
