学习笔记C++_6 设计模式

已于 2024-07-21 18:32:06 修改
阅读量83 收藏
点赞数
文章标签： c++ 设计模式 开发语言
于 2023-11-18 16:49:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RedGown_ovo/article/details/134478653
版权
本文详细介绍了单例模式的三种常见实现（懒汉式、饿汉式和工厂式），比较了它们的优缺点，重点讲解了懒汉式和饿汉式的区别以及工厂设计模式如何解耦对象创建。
摘要由CSDN通过智能技术生成

一、单例模式

1.1 懒汉式

单例模式：
1、当前类最多只能创建一个实例
2、当前这个唯一的实例由自己去创建
3、向整个系统提供全局的公共的接口

懒汉式：当第一次获取实例时，现去创建，时间换空间

#include<iostream>

using namespace std;

class CSingleton {
private:
	CSingleton():m_a(0) /*:m_psin(nullptr)*/ {}
	CSingleton(const CSingleton&) = delete;	//删除类中的拷贝构造函数
	~CSingleton(){}

	static CSingleton* m_psin;

	static class DelSingleton {
	public:
		~DelSingleton() {
			CSingleton::DeleteSingleton();
		}
	}m_delsin;

public:
	//在多线程下可能会创建出多个对象
	static CSingleton* GetSingleton() {
		//加锁
		if (!m_psin)
			m_psin = new CSingleton;
		//解锁
		return m_psin;
	}

	static void DeleteSingleton() {
		if (m_psin)
			delete m_psin;
		m_psin = nullptr;
	}
public:
	int m_a;
};

CSingleton* CSingleton::m_psin = nullptr;
CSingleton::DelSingleton CSingleton::m_delsin;

int main() {
	CSingleton* psin1 = CSingleton::GetSingleton();
	CSingleton* psin2 = CSingleton::GetSingleton();
	cout << psin1 << ' ' << psin2 << endl;	//不同指针，但是同一个对象

	psin1->m_a = 1;
	psin2->m_a = 2;
	cout << psin1->m_a << endl;	//2

	CSingleton::DeleteSingleton();	//回收单例

	psin1 = CSingleton::GetSingleton();
	cout << psin1->m_a << endl;	//0
	//CSingleton sin(*psin1);
}

静态局部特点：当第一次调用这个接口函数，创建出对象后，开始存在，再次调用接口函数不会创建新的对象，而是使用已存在的这个静态局部对象

#include<iostream>

using namespace std;

class CSingleton {
private:
	CSingleton():m_a(0) {}
	CSingleton(const CSingleton&) = delete;	
	~CSingleton(){}

public:
	static CSingleton* GetSingleton() {
		static CSingleton sin;	//静态局部
		return &sin;
	}

public:
	int m_a;
};

int main() {
	CSingleton* psin1 = CSingleton::GetSingleton();
	CSingleton* psin2 = CSingleton::GetSingleton();
	cout << psin1 << ' ' << psin2 << endl;

	psin2->m_a = 2;
	cout << psin1->m_a << endl;	//2

}

1.2 饿汉式

/*
	饿汉式：提前创建好单例，在调用接口时，只是获取这个唯一的实例。空间换时间

*/
#include<iostream>

using namespace std;

class CSingleton {
private:
	CSingleton() :m_a(0) {}
	CSingleton(const CSingleton&) = delete;
	~CSingleton() {}
	static CSingleton sin;
public:
	static CSingleton* GetSingleton() {
		return &sin;
	}

public:
	int m_a;
};

CSingleton CSingleton::sin;

int main() {
	CSingleton* psin1 = CSingleton::GetSingleton();
	CSingleton* psin2 = CSingleton::GetSingleton();
	cout << psin1 << ' ' << psin2 << endl;

	psin2->m_a = 2;
	cout << psin1->m_a << endl;	//2

}

优点：

1、单例模式提供了严格的对唯一实例的创建、访问和销毁，安全性高。（ps:任务处理器）

2、单例模式的的实现可以节省系统资源

1.3 工厂式

主要是用来集中创建对象的，如果在任何使用的地方创建对象那就造成了类或方法之间的耦合。如果要更换对象，就要在所有使用的地方都要修改一遍。优势：解耦。

1.3.1 简单工厂

#include <iostream>

using namespace std;

class CEngine {
public:
	virtual void working() = 0;
};

class CEngine2T :public CEngine {
public:
	void working() {
		cout << "2T" << endl;
	}
};

class CEngine2L :public CEngine {
public:
	void working() {
		cout << "2L" << endl;
	}
};

//简单工厂
class CFactoryEngine {
public:
	CEngine* CreateEngine(string type) {
		if (type == "T")
			return new CEngine2T;
		else if (type == "L")
			return new CEngine2L;
		else return nullptr;
	}
};

class Ccar {
public:
	CEngine* m_pEngine;	//父类指针

	Ccar():m_pEngine(new CEngine2L){}

	Ccar(string type) {
		if (type == "T")
			m_pEngine = new CEngine2T;
		else if (type == "L")
			m_pEngine = new CEngine2L;
		else m_pEngine = nullptr;
	}

	~Ccar() {
		if (m_pEngine) {
			delete m_pEngine;
			m_pEngine = nullptr;
		}
	}

	Ccar(CFactoryEngine* pFac, string type):m_pEngine(pFac?pFac->CreateEngine(type):nullptr) {}

	void run() {
		m_pEngine->working();
		cout << "running" << endl;
	}
};

int main() {
	Ccar car1;
	car1.run();
	Ccar car2("T");
	car2.run();

	CFactoryEngine Fac;
	Ccar car3(&Fac, "L");
	car3.run();
}

1.3.2 工厂方法

#include <iostream>

using namespace std;

class CEngine {
public:
	virtual void working() = 0;
};

class CEngine2T :public CEngine {
public:
	void working() {
		cout << "2T" << endl;
	}
};

class CEngine2L :public CEngine {
public:
	void working() {
		cout << "2L" << endl;
	}
};

//简单工厂
class CFactoryEngine {
public:
	virtual CEngine* CreateEngine() = 0;
};

//工厂方法
class CFacEngine2T :public CFactoryEngine {
public:
	CEngine* CreateEngine() {
		return new CEngine2T;
	}
};

class CFacEngine2L :public CFactoryEngine {
public:
	CEngine* CreateEngine() {
		return new CEngine2L;
	}
};

class Ccar {
public:
	CEngine* m_pEngine;	//父类指针

	Ccar() :m_pEngine(new CEngine2L) {}

	Ccar(string type) {
		if (type == "T")
			m_pEngine = new CEngine2T;
		else if (type == "L")
			m_pEngine = new CEngine2L;
		else m_pEngine = nullptr;
	}

	~Ccar() {
		if (m_pEngine) {
			delete m_pEngine;
			m_pEngine = nullptr;
		}
	}

	Ccar(CFactoryEngine* pFac) :m_pEngine(pFac ? pFac->CreateEngine() : nullptr) {}

	void run() {
		m_pEngine->working();
		cout << "running" << endl;
	}
};

int main() {
	CFactoryEngine* pFac1 = new CFacEngine2L;
	CFactoryEngine* pFac2 = new CFacEngine2T;
	Ccar car(pFac2);
	car.run();

	delete pFac1;
	delete pFac2;
}

1.3.3 抽象工厂

#include <iostream>

using namespace std;

//具体产品
class CEngine {
public:
	virtual void working() = 0;
};

class CEngine2T :public CEngine {
public:
	void working() {
		cout << "2T" << endl;
	}
};

class CEngine2L :public CEngine {
public:
	void working() {
		cout << "2L" << endl;
	}
};

class CGearbox {
public:
	virtual void working() = 0;
};

class CGearboxAuto :public CGearbox {
public:
	virtual void working() {
		cout << "自动挡变速箱正在工作" << endl;
	}
};

class CGearboxManual :public CGearbox {
public:
	virtual void working() {
		cout << "手动挡变速箱正在工作" << endl;
	}
};

class CFactory {
public:
	virtual CEngine* CreateEngine() = 0;
	virtual CGearbox* CreateGearbox() = 0;
};

class CFac2TAuto :public CFactory {
	virtual CEngine* CreateEngine() {
		return new CEngine2T;
	}
	virtual CGearbox* CreateGearbox() {
		return new CGearboxAuto;
	}
};

class Ccar {
public:
	CEngine* m_pEngine;	//父类指针
	CGearbox* m_pCGear;

	Ccar(CFactory* pFac) :m_pEngine(pFac ? pFac->CreateEngine() : nullptr), m_pCGear(pFac ? pFac->CreateGearbox() : nullptr) {};

	~Ccar() {
		if (m_pCGear) {
			delete m_pCGear;
			m_pCGear = nullptr;
		}
		if (m_pEngine) {
			delete m_pEngine;
			m_pEngine = nullptr;
		}
	}

	void run() {
		m_pCGear->working();
		m_pEngine->working();
		cout << "running" << endl;
	}
};

int main() {
	CFactory* pFac = new CFac2TAuto;
	Ccar car(pFac);
	car.run();

}

RedGown_ovo
关注
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
李建忠「设计模式」笔记
weixin_46065476的博客
08-14 3320
李建忠C++设计模式学习笔记
《C++20设计模式》学习笔记---单例模式
BirdsLife的博客
12-08 1287
单例模式并不完全令人厌恶，但是，如果不小心使用，它们会破坏应用程序的可测试性可可重构性。如果必须使用单例模式，请尝试避免直接使用它（如编写SomeComponent.get().foo()），将其指定为依赖项（例如，作为构造函数的参数），并保证所有依赖项都是从应用程序的某个唯一的位置（例如，控制反转容器）获取或初始化的。
C++Primer Plus学习笔记
weixin_45068267的博客
04-08 1972
此博文是通过翻阅C++ Primer Plus中文第6版（2020），逐章学习记录笔记由此学习C++的基础特性和语法知识，有别于其它视频教学+代码+笔记的学习途径，更趋向传统的书籍+代码+笔记学习，Cpp第6版以C++11标准为主，学习C++基础编程绰绰有余.
C++设计模式学习笔记
一世豁然的专栏
02-05 715
一、组件协作 Template Method Strategy Obsever/Event 二、单一职责 Decorator Brige 三、对象创建 Factory Method Abstract Factory Prototype Builder 四、对象性能 Singleton Flyweight 六、接口隔离 Facade Prox...
C++设计模式学习资料
weixin_43579212的博客
08-17 340
C++设计模式学习资料
C++设计模式笔记
Apathetical的博客
04-05 3895
C++设计模式笔记前言模块方法 (Template Method)策略模式 (Strategy)观察者模式 (Observer)装饰器 (Decorator)桥模式 (Bridge) 前言 之前面试游戏各大厂跟游戏新贵的时候，总是被问到“设计模式”相关内容，但我由于在本科和研究生期间并没有学过这个东西，唯一的了解也就是在腾讯实习的时候，组内开发的游戏使用了MVC架构。痛定思痛，提交了毕设论文盲审之后，打算了解一下“设计模式”是什么，所以本文打算记录一下b站《C++设计模式》的学习经历。 我自己对于“设计模式
c++基础全套学习笔记（入门）
lzq00277的博客
10-03 4204
C++入门
《C++20设计模式》学习笔记配套代码
qq_41668147的博客
02-02 579
由于该书并没有提供配套源码，书中的代码由于篇幅或翻译原因，有不少省略甚至错误，无法直接运行，感觉比较打击学习者的信心。并且在网上公开资源也没有找到完整的代码。因此，我准备将个人在学习过程中的代码提交上来，供同行者参考。
C++设计模式——策略模式(Strategy Pattern)
leonardohaig的博客
05-30 2950
C++设计模式——策略模式(Strategy Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——策略模式(Strategy Pattern)目录定义实现示例传统的策略模式实现使用函数指针实现策略模式工厂模式和策略模式对比总结参考资料 定义 Define a family of algorithms,encapsulate each one,and make them interchangeable. 定义一组算法，将每个算法都封装起来，并且使它们之间可以互换 策略模式是指定
《C++20设计模式》学习笔记-第6章适配器模式学习代码
02-06
《C++20设计模式》学习笔记-第6章适配器模式学习代码
《C++20设计模式》学习笔记-第5章单例模式
02-05
《C++20设计模式》学习笔记-第5章单例模式
C++20设计模式学习笔记-第7章桥接模式学习代码
02-06
C++20设计模式学习笔记-第7章桥接模式学习代码
《C++20设计模式》学习笔记-第2章构造器模式学习代码
02-04
在C++编程中，设计模式是一种经过验证的解决常见问题的最佳实践。《C++20设计模式》一书深入探讨了如何在C++20这一最新标准中应用这些模式。第2章着重讲解了构造器模式，这是一种创建型设计模式，它关注的是对象的...
《C++20设计模式》学习笔记-第8章组合模式-配套学习代码
02-20
《C++20设计模式》学习笔记-第8章组合模式-配套学习代码
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1663
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
将脚本编译为pyd文件
cdinten的专栏
10-01 427
Python虽然作为一种解释性语言，通常是使用解释器处理脚本的方式完成工作，但是也具有和很多其他诸如C、C#语言等类似的方式，可以将.py文件编译为*.pyd文件，即Python动态链接库文件。关于动态链接库的优缺点这里就不展开细说了，具体介绍如何编译及使用。要将Python文件编译成.pyd文件，可以使用Cython，以下是基本的操作步骤。
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 410
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
C++：图的最短路径问题
最新发布
han2205277149的博客
10-04 631
最短路径问题是图的一个比较典型的应用问题。例如，给定某公路网的n个城市以及这些城市之间相通公路的距离，能否找到城市A到城市B之间一条距离最近的通路呢？如果将城市用顶点表示城市间的公路用边表示，公路的长度作为边的权值，这个问题就归结为在网图中求顶点A和顶点B的最短路径。
C++实现的23种设计模式详解与应用
《设计模式》学习笔记是一份详尽的文档，主要介绍了如何理解和应用23种面向对象设计模式，使用C++编程语言进行通俗易懂的实现。设计模式被定义为面向对象软件开发中的通用解决方案，它们针对特定的软件问题提供了一...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值