C++设计模式

最新推荐文章于 2024-01-25 11:45:00 发布
最新推荐文章于 2024-01-25 11:45:00 发布
阅读量933 收藏 5
点赞数 1
分类专栏： 学习笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzh123353/article/details/121625025
版权

C++设计模式

从面向对象谈起

底层思维： 语言构造、编译转换、内存模型、运行时机制
抽象思维 ：面向对象、组件封装、设计模式、架构模式
在这里插入图片描述

深入理解面向对象

向下： 深入理解三大面向对象机制
1.封装，隐藏内部实现
2.继承，复用现有代码
3.堕胎，改写对象行为
向上： 深刻把握面向对象机制所带来的抽象意义，理解如何使用这些机制来表达现实世界，掌握什么是好的“面向对象设计”
在这里插入图片描述

重新认识面向对象

理解隔离变化
从宏观层面来看，面向对象的构建方式更能适应软件的变化，能将变化所带来的影响最小
各司其职
从微观层面来看，面向对象的方式更强调各个类的“责任”；
由于需求变化导致新增类型不应该影响原来类型的实现–是所谓各司其职
对象
从语言实现层面，对象封装了代码和数据；
从规格层面来看，对象是一系列可被使用的公共接口；
从概念层面讲，对象是某种拥有责任的抽象。

设计原则

1.依赖倒置原则（DIP）：
高层模块（稳定）不应该依赖于底层模块（变化），二者都应该改依赖于抽象(稳定)
抽象（稳定）不应该依赖于实现细节(变化)，实现细节应该依赖于抽象(稳定)。

2.开放封闭原则(OCP) :
对扩展开放，对更改封闭；
类模块应该是可扩展的，但是不可修改！

3.单一职责原则(SRP) ：
一个类应该仅有一个引起它变化的原因；
变化的方向隐含类的责任。

4.Liskov替换原则（LSP）：
子类必须能够替换他们的基类(IS-A)；
继承表达类型抽象。

5.接口隔离原则(ISP) ：
不应该强迫客户程序依赖它们不用的方法；
接口应该小而完备

6.优先使用对象组合，也不是使用类继承
类继承通常为“白箱复用”，对象组合通常为“黑箱复用”；
继承在某种程度上破坏了封装性，子类父类耦合度高；
而对象组合只需要被组合的对象具有良好定义的接口定义

7.封装变化点
使用封装来创建对象之间的分界层，让设计者可以在分界层，一侧进行修改，
而不会对另一侧产生不良影响，从而实现层次间的松耦合；

8.针对接口编程，而不是针对实现编程
不将变量类型声明为某个特定的具体类，而是声明为某个接口；
客户程序无需获知对象的具体类型，只需要知道对象所具有的接口；
减少系统中各部分的依赖关系，实现“高内聚、松耦合”的类型设计方案；

将设计原则提升为设计经验

1.设计习语
2.设计模式
3.架构模式

文章目录

模式分类

重构获得模式

在这里插入图片描述

“组件协作模式”

在这里插入图片描述

Template Method模式

在这里插入图片描述
结构化设计：
在这里插入图片描述
在这里插入图片描述

//程序库开发人员
class Library {
public:
	void Step1() {
	//...
	}

	void Step3() {
		//...
	}

	void Step5() {
		//...
	}

};
//应用程序开发人员
class Application {
public:
	bool Step2() {
		//...
	}

	void Step4() {
		//...
	}
};
int main() {
	Library lib;
	Application app;

	lib.Step1();
	
	if (app.Step2()) {
		lib.Step3();
	}

	for (int i = 0; i < 4; ++i) {
		app.Step4();
	}

	lib.Step5();
}

面向对象软件设计流程：

在这里插入图片描述
在这里插入图片描述

//程序库开发人员
class Library {
public:
	//稳定 template method
	void run() {
				Step1();
		if (Step2()) {
			Step3();
		}
		for (int i = 0; i < 4; ++i) {
			Step4();
		}

		Step5();
	}
	virtual ~Library() {};
protected:
	void Step1() {  //稳定
		//...
	}

	void Step3() {  //稳定
		//...
	}

	void Step5() {  //稳定
		//...
	}
	virtual bool Step2() = 0; //变化
	virtual void Step4() = 0;//变化
};

class Application :public Library {
protected:
	virtual bool Step2() {
		//...子类重写实现
	}

	virtual void Step4() {
		//...子类重写实现
	}
};

int main() {
	Library* pLib = new Application();
	pLib->run();
	delete pLib;
}

在这里插入图片描述
体系结构:
在这里插入图片描述

Strategy模式

在这里插入图片描述

下面是违背开放封闭原则的设计，更改时候直接改了源代码，而不是进行扩展，还需要重新编译，测试

enum TaxBase {
	CN_Tax,
	US_Tax,
	DE_tax,
	FR_tax //更改
};

class SalesOrder {
	TaxBase tax;
public:
	double CalculateTax() {
		//....
		if (tax == CN_Tax) {
			//...
		}
		else if (tax == US_Tax) {
			//...
		}
		else if (tax == DE_tax) {
			//...
		}
		else if(tax == FR_tax){  //更改
		  //...                    
		}
	}
	//...
};

面向对象设计：

class TaxStrategy {
public:
	virtual double Calculate(const Context& context) = 0;
	virtual ~TaxStrategy();
};

class CNTax :public TaxStrategy {
public:
	virtual double Calculate(const Context& context) {
		//中国税法
	}
};


class USTax :public TaxStrategy {
public:
	virtual double Calculate(const Context& context) {
		//美国税法
	}
};


class DETax :public TaxStrategy {
public:
	virtual double Calculate(const Context& context) {
		//德国税法
	}
};

//扩展更改
class FRTax :public TaxStrategy {
public:
	virtual double Calculate(const Context& context) {
		//法国税法
	}
};

class SalesOrder {
private:
	TaxStrategy* strategy;
public:
	SalesOrder(StrtegyFactory* str) {
		this->strategy = str->NewStrategy();
	}
	~SalesOrder() {
		delete this->strategy;
	}

	public double CalculateTax() {
		//...
		Context context();

		double val = strategy->Calculate(context); //多态调用
		//...
	}
};

体系结构：
在这里插入图片描述
在这里插入图片描述

Observer / Event模式

在这里插入图片描述
在这里插入图片描述

观察者模式案例：

#include <string>
#include <iostream>
#include <vector>
#include <list>

class IProgress {
public:
	virtual void DoProgress(float value) = 0;
	virtual ~IProgress();
};

class ConsoleNotifier:public IProgress {
public:
	virtual void DoProgress(float value) {
		std::cout << ".";
	}
};
class MainForm : public Form, public IProgress{
	TextBox* txtFilePath;
	TextBox* txtFileNumber;

	ProgressBar* progressBar;  //通知控件

public:
	void Button1_Click() {
		std::string filePath = txtFilePath->getText();
		int number = atoi(txtFileNumber->getText().c_str());
		ConsoleNotifier cn;

		FileSplitter splitter(filePath, number);
		splitter.add_IProgress(this);   //加入次观察者，订阅通知
		splitter.add_IProgress(&cn);   //加入其他观察者，订阅通知

		splitter.split();
	}
	virtual void DoProgress(float value) {
		progressBar->setValue(value);
	}

};

class FileSplitter {
	std::string m_filePath;
	int m_fileNumber;
	//ProgressBar* m_progressBar;  //通知控件
	std::list <IProgress* > m_iprogressList;    //抽象通知机制,支持多个观察者

public:
	//FileSplitter(const std::string& filePath, int fileNumber, ProgressBar* progressBar) :
	//	m_filePath(filePath),
	//	m_fileNumber(fileNumber),
	//	m_progressBar(progressBar) { 
	//}
	FileSplitter(const std::string& filePath, int fileNumber) :
		m_filePath(filePath),
		m_fileNumber(fileNumber) {

    	}
	void add_IProgress(IProgress* iprogress) {
		m_iprogressList.add(iprogress);
	}
	void remove_IProgress(IProgress* iprogress) {
		m_iprogressList.remove(iprogress);
	}
	void split() {
		//1.读取文件

		 //2.分批次向小文件写入
		for (int i = 0; i < m_fileNumber; ++i) {
			//....
			//if (m_progressBar != nullptr) {
			//	m_progressBar->setvalue((i + 1) * 100.0 / m_fileNumber);
			//}
		
				float progressValue = m_fileNumber;
				progressValue = (i + 1) / progressValue;
				onProgress(progressValue); //发送通知
		}
	}
protected:
	void onProgress(float progressValue) {
		auto start = m_iprogressList.begin();
		while (start != m_iprogressList.end()) {
			(*start)->DoProgress(progressValue);  //更新进度条
			start++;
		}
	}
};

在这里插入图片描述
在这里插入图片描述

装饰模式

"单一职责"模式

在这里插入图片描述

Decorator

在这里插入图片描述
案例：
在这里插入图片描述

//业务操作
class Stream {
public:
	virtual char Read(int number) = 0;
	virtual void Seek(int position) = 0;
	virtual void Write(char data) = 0;

	virtual ~Stream();
};

//主体类
class FileStream : public Stream {
public:
	virtual char Read(int number) {
		//读文件流	
	}

	virtual void Seek(int position) {
		//定位文件流
	}

	virtual void Write(char data) {
		//写文件流
	}
};

//扩展操作
class CryptoFileStream : public FileStream {
public:
	virtual char Read(int number) {
		//额外加密操作
		FileStream::Read(number);//读文件流	
	}

	virtual void Seek(int position) {
		//额外加密操作
		FileStream::Seek(position);//定位文件流
	}

	virtual void Write(char data) {
		//额外加密操作
		FileStream::Write(data);//写文件流
	}
};

class BufferreadStream :public FileStream {
public:
	virtual char Read(int number) {
		//额外加密操作
		FileStream::Read(number);//读文件流	
	}

	virtual void Seek(int position) {
		//额外加密操作
		FileStream::Seek(position);//定位文件流
	}

	virtual void Write(char data) {
		//额外加密操作
		FileStream::Write(data);//写文件流
	}
};

void Progress() {
	//编译时装配
	CryptoStream* fs1 = new CryptoStream();
	BufferreadStream* fs2 = new BufferreadStream();
}

改进后：
在这里插入图片描述

//业务操作
//业务操作
class Stream {
public:
	virtual char Read(int number) = 0;
	virtual void Seek(int position) = 0;
	virtual void Write(char data) = 0;

	virtual ~Stream();
};

//主体类
class FileStream : public Stream {
public:
	virtual char Read(int number) {
		//读文件流	
	}

	virtual void Seek(int position) {
		//定位文件流
	}

	virtual void Write(char data) {
		//写文件流
	}
};

//扩展操作
class Decorator: public Stream{
protected:
	Stream* stream;
	Decorator(Stream* stm) :stream(stm) {}
};

class CryptoStream:public Decorator {
public:
	CryptoStream(Stream* stm) :Decorator(stm) {
	}
	virtual char Read(int number) {
		//额外加密操作
		stream->Read(number);//读文件流	
	}

	virtual void Seek(int position) {
		//额外加密操作
		stream->Seek(position);//定位文件流
	}

	virtual void Write(char data) {
		//额外加密操作
		stream->Write(data);//写文件流
	}
};

class BufferreadStream :public Decorator {
	Stream* stream; // ...
	//...
public:
	BufferreadStream(Stream* stm) :Decorator(stm) {
	}
	virtual char Read(int number) {
		//额外加密操作
		stream->Read(number);//读文件流	
	}

	virtual void Seek(int position) {
		//额外加密操作
		stream->Seek(position);//定位文件流
	}

	virtual void Write(char data) {
		//额外加密操作
		stream->Write(data);//写文件流
	}
};

void Progress() {
	//运行时装配
	FileStream* s1 = new FileStream();
	CryptoStream* s2 = new CryptoStream(s1);
	BufferreadStream* s3 = new BufferreadStream(s1);

}

定义：
在这里插入图片描述
体系结构：
在这里插入图片描述
在这里插入图片描述

Bridge

在这里插入图片描述
在这里插入图片描述

冗余设计：

#include <string>
class Messager {
public:
	virtual void Login(std::string username, std::string password) = 0;
	virtual void SendMessage(std::string message) = 0;
	virtual void SendPicture(Image image) = 0;
	
	virtual void PlaySound() = 0;
	virtual void DrawShape() = 0;
	virtual void WriteText() = 0;
	virtual void Connect() = 0;

	virtual ~Messager();
};

//平台实现
class PCMessagerBase :public Messager {
public:
	virtual void PlaySound() {
		//***
	}

	virtual void DrawShape() {
		//***
	}

	virtual void WriteText() {
		//***
	}

	virtual void Connect() {
		//***
	}
};

class MobileMessagerBase :public Messager {
public:
	virtual void PlaySound() {
		//***
	}

	virtual void DrawShape() {
		//***
	}

	virtual void WriteText() {
		//***
	}

	virtual void Connect() {
		//***
	}
};

//业务抽象
class PCMessagerLite :public PCMessagerBase {
public:
	virtual void Login(std::string username, std::string password) {
		PCMessagerBase::Connect();
		//....
	}

	virtual void SendMessage(std::string message) {
		PCMessagerBase::WriteText();
		//....
	
	}

	virtual void SendPicture(Image image) {
		PCMessagerBase::DrawShape();
		//...
	}
};

class PCMessagerPerfect :public PCMessagerBase {
public:
	virtual void Login(std::string username, std::string password) {
		PCMessagerBase::PlaySound();
		//***
		PCMessagerBase::Connect();
		//....
	}

	virtual void SendMessage(std::string message) {
		PCMessagerBase::PlaySound();
		//***
		PCMessagerBase::WriteText();
		//....

	}

	virtual void SendPicture(Image image) {
		PCMessagerBase::PlaySound();
		//***
		PCMessagerBase::DrawShape();
		//...
	}
};

class MobileMessagerLite :public MobileMessagerBase {
public:
	virtual void Login(std::string username, std::string password) {
		MobileMessagerBase::Connect();
		//....
	}

	virtual void SendMessage(std::string message) {
		MobileMessagerBase::WriteText();
		//....

	}

	virtual void SendPicture(Image image) {
		MobileMessagerBase::DrawShape();
		//...
	}
};

class MoblieMessagerPerfect :public MobileMessagerBase {
public:
	virtual void Login(std::string username, std::string password) {
		MobileMessagerBase::PlaySound();
		//***
		MobileMessagerBase::Connect();
		//....
	}

	virtual void SendMessage(std::string message) {
		MobileMessagerBase::PlaySound();
		//***
		MobileMessagerBase::WriteText();
		//....

	}

	virtual void SendPicture(Image image) {
		MobileMessagerBase::PlaySound();
		//***
		MobileMessagerBase::DrawShape();
		//...
	}
};

优化设计：

#include <string>
class Messager {
protected:
	MessagerImp* messager;
public:
	Messager(MessagerImp* m) :messager(m) {}
	virtual void Login(std::string username, std::string password) = 0;
	virtual void SendMessage(std::string message) = 0;
	virtual void SendPicture(Image image) = 0;

	virtual ~Messager();
};

class MessagerImp {
public:
	virtual void PlaySound() = 0;
	virtual void DrawShape() = 0;
	virtual void WriteText() = 0;
	virtual void Connect() = 0;

	virtual ~MessagerImp();
};


//平台实现
class PCMessagerImp :public MessagerImp {
public:
	virtual void PlaySound() {
		//***
	}

	virtual void DrawShape() {
		//***
	}

	virtual void WriteText() {
		//***
	}

	virtual void Connect() {
		//***
	}
};

class MobileMessagerImp :public MessagerImp {
public:
	virtual void PlaySound() {
		//***
	}

	virtual void DrawShape() {
		//***
	}

	virtual void WriteText() {
		//***
	}

	virtual void Connect() {
		//***
	}
};


//业务抽象
class MessagerLite :public Messager {
public:
	MessagerLite(MessagerImp* m) :Messager(m) {}
	virtual void Login(std::string username, std::string password) {
		messager->Connect();
		//....
	}

	virtual void SendMessage(std::string message) {
		messager->WriteText();
		//....
	
	}

	virtual void SendPicture(Image image) {
		messager->DrawShape();
		//...
	}
};

class MessagerPerfect :public Messager {
public:
	MessagerPerfect(MessagerImp* m) :Messager(m) {}
	virtual void Login(std::string username, std::string password) {
		messager->PlaySound();
		//***
		messager->Connect();
		//....
	}

	virtual void SendMessage(std::string message) {
		messager->PlaySound();
		//***
		messager->WriteText();
		//....

	}

	virtual void SendPicture(Image image) {
		messager->PlaySound();
		//***
		messager->DrawShape();
		//...
	}
};

void Process(){
	MessagerImp* imp = new PCMessagerImp();
	Messager* m = new MessagerPerfect(imp);

}

体系结构：
在这里插入图片描述

在这里插入图片描述

工厂方法模式

在这里插入图片描述

"对象创建"模式

Factory Method

在这里插入图片描述

细节依赖导致的紧耦合：

#include <string>
#include <iostream>
#include <vector>
#include <list>


class MainForm : public Form, public IProgress {
	TextBox* txtFilePath;
	TextBox* txtFileNumber;

	ProgressBar* progressBar;  //通知控件

public:
	void Button1_Click() {
		std::string filePath = txtFilePath->getText();
		int number = atoi(txtFileNumber->getText().c_str());

		ISplitter splitter = 
			new BinarySplitter(filePath, number);//依赖具体类
		splitter.split();
	}
	virtual void DoProgress(float value) {
		progressBar->setValue(value);
	}

};
class ISplitter {
public:
	virtual void split() = 0;
	virtual ~ISplitter() {}
};
class BinarySplitter:public ISplitter {

};
class TxtSplitter:public ISplitter {

};

class PictureSplitter :public ISplitter {

};
class VideoSplitter :public ISplitter {

};

工厂设计模式：

#include <string>


class MainForm : public Form{
	SplitterFactory* factory;

public:
	MainForm(SplitterFactory* factory) {
		this->factory = factory;
	}
	void Button1_Click() {
		ISplitter* splitter = factory->CreateSplitter();  //多态new

		splitter->split();
	}
};
class ISplitter {
public:
	virtual void split() = 0;
	virtual ~ISplitter() {}
};

class SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() = 0;
	~SplitterFactory();
};

class BinarySplitter:public ISplitter {
	virtual void split() {
	}
};
class TxtSplitter:public ISplitter {
	virtual void split() {
	}
};

class PictureSplitter :public ISplitter {
	virtual void split() {
	}
};
class VideoSplitter :public ISplitter {
	virtual void split() {
	}
};

//具体工厂
class BinarySplitterFactory :public SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() {
		return new BinarySplitter();
	}
};

class TxtSplitterFactory :public SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() {
		return new TxtSplitter();
	}
};

class PictureSplitterFactory :public SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() {
		return new PictureSplitter();
	}
};

class VideoSplitterFactory :public SplitterFactory {
public:
	virtual ISplitter* CreateSplitter() {
		return new VideoSplitter();
	}
};

在这里插入图片描述
在这里插入图片描述

抽象工厂

在这里插入图片描述
在这里插入图片描述

#include<vector>
//数据库访问有关的基类
class IDBConnection {

};
class IDBCommand {

};
class IDataReader {

};

class IDBFactory {
public:
	virtual IDBConnection* CreateDBConnection() = 0;
	virtual IDBCommand* CreateDBCommand() = 0;
	virtual IDataReader* CreateDataReader() = 0;
};

//支持SqlServer
class SqlConnection : public IDBConnection {

};

class SqlCommand :public IDBCommand {

};

class SqlDataReader :public IDataReader {

};

class SqlDBFactory :public IDBnFactory {
	virtual IDBConnection* CreateDBConnection() {
		return new SqlConnection();
	}
	virtual IDBCommand* CreateDBCommand() {
		return new SqlCommand();
	}
	virtual IDataReader* CreateDataReader() {
		return new SqlDataReader();
	}
};


//支持Oracle
class OracleConnection : public IDBConnection {

};

class OracleCommand :public IDBCommand {

};

class OracleDataReader :public IDataReader {

};

class OracleDBFactory :public IDBnFactory {
	virtual IDBConnection* CreateDBConnection() {
		return new SqlConnection();
	}
	virtual IDBCommand* CreateDBCommand() {
		return new SqlCommand();
	}
	virtual IDataReader* CreateDataReader() {
		return new SqlDataReader();
	}
};

class EmployeeDAO {
	IDBFactory* dbfactory;
public:
	std::vector<EmployeeDAO> GetEmployees() {
		IDBConnection* connection =
			dbfactory->CreateDBConnection();
		
		IDBCommand* command =
			dbfactory->CreateDBCommand();

		command->SetConnection(connection);  //关联性

		
		IDataReader* reader =
			dbfactory->CreateDataReader();
		while (reader->Read()) {
		
		}
	}
};

在这里插入图片描述

在这里插入图片描述

原型模式

在这里插入图片描述
在这里插入图片描述

//抽象类
class ISplitter {
public:
	virtual void split() = 0;
	virtual ~ISplitter() {}
	virtual ISplitter* clone() = 0;  //通过克隆自己去创建对象
};
class BinarySplitter :public ISplitter {
	virtual void split() {}
	virtual  ISplitter* clone() {
		return new BinarySplitter(*this);
	}
};
class TxtSplitter :public ISplitter {
	virtual void split() {}
	virtual ISplitter* clone() {
		return new TxtSplitter(*this);
	}
};

class PictureSplitter :public ISplitter {
	virtual void split() {}
	virtual ISplitter* clone() {
		return new PictureSplitter(*this);
	}
};
class VideoSplitter :public ISplitter {
	virtual void split() {}
	virtual ISplitter* clone() {
		return new VideoSplitter(*this);
	}
};
class MainForm : public Form {
	ISplitter* factory;

public:
	MainForm(ISplitter* factory) {
		this->factory = factory;  //原型对象
	}
	void Button1_Click() {
		ISplitter* splitter = factory->clone();  //

		splitter->split();
	}
};

在这里插入图片描述
在这里插入图片描述

构建器

在这里插入图片描述
在这里插入图片描述

class House {
	//...
};

class HouseBuilder {
public:

	House* GetRes() {
		return pHouse;
	}
	virtual ~HouseBuilder();
protected:
	House* pHouse;
	virtual void BuildPart1() = 0;
	virtual void BuildPart2() = 0;
	virtual bool BuildPart3() = 0;
	virtual void BuildPart4() = 0;
	virtual void BuildPart5() = 0;
};
class HouseDirector {
public:
	HouseBuilder* pHouseBuilder;
	HouseDirector(HouseBuilder* p) {
		this->pHouseBuilder = p;
	}
	House* Construct() {
		//C++构造函数是静态绑定
		pHouseBuilder->BuildPart1();
		for (int i = 0; i < 4; ++i) {
			pHouseBuilder->BuildPart2();
		}
		bool flag = pHouseBuilder->BuildPart3();
		if (flag) {
			pHouseBuilder->BuildPart4();
		}
		pHouseBuilder->BuildPart5();

		return pHouseBuilder->GetRes();
	}

};

class StoneHouse :public House {
};
class StoneHouseBuilder :public HouseBuilder {
protected:
	virtual void BuildPart1() {

	}
	virtual void BuildPart2() {

	}

	virtual bool BuildPart3() {

	}
	virtual void BuildPart4() {

	}
	virtual void BuildPart5() {

	}
};

int main() {
	House* pHouse = new StoneHouse();
}

在这里插入图片描述
在这里插入图片描述

对象性能模式

Singleton

主要解决性能上的问题，不是上面工厂上的紧耦合问题！
在这里插入图片描述
简单写法：但是存在一个问题，单线程下安全，多线程下会存在安全问题

class Singleton {
private:
	Singleton();
	Singleton(const Singleton& other);
public:
	static Singleton* getInstance();
	static Singleton* m_instance;
};
Singleton* Singleton::m_instance = nullptr;


//线程非安全版本
Singleton* Singleton::getInstance() {
	if (m_instance == nullptr) {
		m_instance = new Singleton();
	}
	return m_instance;
}

解决办法：

#include <atomic>
#include <mutex>

class Singleton {
private:
	Singleton();
	Singleton(const Singleton& other);
public:
	static Singleton* getInstance();
	static Singleton* m_instance;
	static std::mutex m_mutex;
};
Singleton* Singleton::m_instance = nullptr;


//线程非安全版本(多线程下不安全)
Singleton* Singleton::getInstance() {
	if (m_instance == nullptr) {
		m_instance = new Singleton();
	}
	return m_instance;
}

//线程安全版本，加锁，但是代价比较高
Singleton* Singleton::getInstance() {
	Lock lock;
	if (m_instance == nullptr) {
		m_instance = new Singleton();
	}
	return m_instance;
}


//双检查锁，但由于内存读写reorder不安全  
//锁前锁后都检查一次
//锁前检查代价高 跟上面一样
//锁后不检查 有时候会发生错误，创建不止1个对象
Singleton* Singleton::getInstance() {
	if (m_instance == nullptr) {
		Lock lock;
		if (m_instance == nullptr) {
			m_instance = new Singleton();
		}
	}
	return m_instance;
}


//C++11版本之后跨平台实现(volatile) 
std::atomic<Singleton*> Singleton::m_instance;
std::mutex Singleton::m_mutex;
Singleton* Singleton::getInstance() {
	Singleton* tmp = m_instance.load(std::memory_order_relaxed);
	std::atomic_thread_fence(std::memory_order_acquire); //获取内存fence
	if (tmp == nullptr) {
		std::lock_guard<std::mutex> lock(m_mutex);
		tmp = m_instance.load(std::memory_order_relaxed);
		if (tmp == nullptr) {
			tmp = new Singleton;
			std::atomic_thread_fence(std::memory_order_release); //释放内存fence
			m_instance.store(tmp, std::memory_order_relaxed);
		}
	}
	return tmp;
}

定义：
在这里插入图片描述
结构：
在这里插入图片描述

要点总结：
在这里插入图片描述

Flyweight

在这里插入图片描述
模式定义：
在这里插入图片描述

#include <string>
#include <map>

class Font {
private:

	//unique object key
	std::string key;

	//object state
	//...
public:
	Font(const std::string& key) {
		//...
	}
};

class FontFactory {
private:
	std::map<std::string, Font*> fontPool;

public:
	Font* GetFont(const std::string& key) {
		std::map<std::string, Font*>::iterator item = fontPool.find(key);
		if (item != fontPool.end()) {
			return fontPool[key];
		}
		else {
			Font* font = new Font(key);
			fontPool[key] = font;
			return font;
		}
	}

	void clear() {
		//....
	}
};

结构：
在这里插入图片描述
总结：
在这里插入图片描述

接口隔离模式

在这里插入图片描述

facade

在这里插入图片描述
在这里插入图片描述

模式定义：
在这里插入图片描述

结构：
在这里插入图片描述
在子系统和外系统中的一种解耦方式，用一个稳定的接口去隔离变化的部分。
在这里插入图片描述

Proxy代理模式

在这里插入图片描述

定义：
在这里插入图片描述
结构：
在这里插入图片描述
原始代码：存在问题，可能是性能、控制、分布式等

class ISubject {
public:
	virtual void process();
};

class RealSubject :public ISubject {
public:
	virtual void process() {
		//...
	}
};

class ClientApp {
	ISubject* subject;
public:
	ClientApp() {
		subject = new RealSubject();
	}
	void DoTask() {

		//...
		subject->process();
		//...

	}

};

Proxy：

class ISubject {
public:
	virtual void process();
};

//Proxy的设计  作为realSubject的代理
class SubjectProxy :public ISubject {
public:
	virtual void process() {
		//...对RealSubject得一种间接访问
		//...
	}
};

class ClientApp {
	ISubject* subject;
public:
	ClientApp() {
		subject = new SubjectProxy();
	}
	void DoTask() {

		//...
		subject->process();
		//...

	}

};

总结：
在这里插入图片描述

Adapter

在这里插入图片描述
模式定义：
在这里插入图片描述
结构：
在这里插入图片描述

#include <deque>
//目标接口(新街口)
class ITarget {
public:
	virtual void process() = 0;
};

//遗留接口（老接口）
class IAdaptee {
public:
	virtual void foo(int data) = 0;
	virtual int bar() = 0;
};

//遗留类型
class OldClass:public IAdaptee{
	//....
};

//遵循ITarget的接口规范
class Adatpter :public ITarget {
protected:
	IAdaptee* pAdaptee;
public:
	Adatpter(IAdaptee* p) :pAdaptee(p) {}

	virtual void process() {
		int data = pAdaptee->bar();
		pAdaptee->foo(data);
	}
};

int main() {
	IAdaptee* pAdaptee = new OldClass();

	ITarget* pTarget = new Adatpter(pAdaptee);
	pTarget->process();
}


//C++源码中栈和队列的实现
template<class type>
class stack {
	std::deque<type> container;
	//...各种接口
};

template<class type>
class queue {
	std::deque<type> container;
	//...各种接口
};

在这里插入图片描述

中介者

在这里插入图片描述
模式定义：
在这里插入图片描述
结构：
在这里插入图片描述
引入中介者，改变对象之间的复杂的引用关系。
在这里插入图片描述

状态变化模式

.在这里插入图片描述

State

在这里插入图片描述
模式定义：
在这里插入图片描述

原始代码：有太多的if，else语句，如果网络状态发生增删，需要大幅度改动原本代码

enum NetworkState {
	Network_Open,
	Network_Close,
	Network_Connect
};

class NetworkProcessor {
	NetworkState state;

public:
	void Opetation1() {
		if (state == Network_Open) {
			//........
			state = Network_Close;
		}
		else if (state == Network_Close) {
			//....
			state = Network_Connect;
		}
		else if (state == Network_Connect) {
			//....
			state = Network_Open;
		}
		else if(...)
	}

	void Opetation1() {
		if (state == Network_Open) {
			//........
			state = Network_Connect;
		}
		else if (state == Network_Close) {
			//....
			state = Network_Open;
		}
		else if (state == Network_Connect) {
			//....
			state = Network_Close;
		}
		else if(...)
	}

};

更改后：再增加的时候，只需要增加类状态就行，不需要改变Processor的状态，即处于稳定状态，通过扩展子类可以实现。

enum NetworkState {
	Network_Open,
	Network_Close,
	Network_Connect
};

class NetworkProcessor {
	NetworkState state;

public:
	void Opetation1() {
		if (state == Network_Open) {
			//........
			state = Network_Close;
		}
		else if (state == Network_Close) {
			//....
			state = Network_Connect;
		}
		else if (state == Network_Connect) {
			//....
			state = Network_Open;
		}
	}

	void Opetation1() {
		if (state == Network_Open) {
			//........
			state = Network_Connect;
		}
		else if (state == Network_Close) {
			//....
			state = Network_Open;
		}
		else if (state == Network_Connect) {
			//....
			state = Network_Close;
		}
	}
};

class	NetWorkState {
public:
	NetWorkState* pNext;
	virtual void Operation1() = 0;
	virtual void Operation2() = 0;
	virtual void Operation3() = 0;

	virtual ~NetWorkState();
};

class OpenState :public NetWorkState {
	static NetWorkState* m_instance;
public:
	static NetWorkState* getInstance() {
		if (m_instance == nullptr) {
			m_instance = new OpenState();
		}
		return m_instance;
	}
	virtual void Operation1() {
		//....
		pNext = CloseState::getInstance();
	};
	virtual void Operation2() {
		//...
		pNext = ConnectState::getInstance();
	};
	virtual void Operation3() {
		//.....
		pNext = OpenState::getInstance();
	};
};

class CloseState :public NetWorkState {
	static NetWorkState* m_instance;
public:
	static NetWorkState* getInstance() {
		if (m_instance == nullptr) {
			m_instance = new OpenState();
		}
		return m_instance;
	}
	virtual void Operation1() {
		//....
		
	};
	virtual void Operation2() {

	};
	virtual void Operation3() {

	};
};

class ConnectState :public NetWorkState {
	static NetWorkState* m_instance;
public:
	static NetWorkState* getInstance() {
		if (m_instance == nullptr) {
			m_instance = new OpenState();
		}
		return m_instance;
	}
	virtual void Operation1() {
		//....
		pNext = CloseState::
	};
	virtual void Operation2() {
	};
	virtual void Operation3() {
	};
};

class NetWorkProcessor {
	NetWorkState* pSate;
public:
	NetWorkProcessor(NetWorkState* pState) {
		this->pSate = pSate;
	}

	void operation1() {
		//...
		pSate->Operation1();
		pSate = pSate->pNext;
		//...
	}

	void operation2() {
		//...
		pSate->Operation2();
		pSate = pSate->pNext;
		//...
	}

	void operation3() {
		//...
		pSate->Operation3();
		pSate = pSate->pNext;
		//...
	}
};

结构：
在这里插入图片描述

在这里插入图片描述

备忘录 Memento

在这里插入图片描述
模式定义：
在这里插入图片描述

#include <string>

class Memento {
	std::string state;
	//...
public:
	Memento(const std::string& s) :state(s) {}
	std::string getState() const { return state; }
	void setState(const std::string& s) { state = s; }
};


class Originator {
	std::string state;
	//....
public:
	Originator() {}
	Memento createMemento() {
		Memento m(state);  //实际实现可能相当复杂
		return m;
	}

	void setMemento(const Memento& m) {
		state = m.getState();
	}
};

int main() {
	Originator originator;
	//捕获对象状态, 存储到备忘录 
	Memento mem = originator.createMemento();

	//...改变originator 的状态

	//从备忘录中恢复
	originator.setMemento(mem);
}

结构：
在这里插入图片描述
在这里插入图片描述

数据结构模式

Composite

在这里插入图片描述
模式定义：
在这里插入图片描述
Composite处理
树形结构，多态调用

#include <string>
#include <list>
#include <iostream>
class Component {
public:
	virtual void process() = 0;
	virtual ~Component() {};
};


class Composite : public Component {
	std::string name;
	std::list<Component*> elements;
public:
	Composite(const std::string& s) :name(s) {}
	void add(Component* element) {
		elements.push_back(element);
	}
	void remove(Component* element) {
		elements.remove(element);
	}

	void process() {
		//1.process current node
		std::cout << name << std::endl;
		//2.process leaf nodes
		for (auto& e : elements) {
			e->process();  //多态调用
		}
	}
};

//叶子节点
class Leaf : public Component {
	std::string name;
public:
	Leaf(std::string s) :name(s) { }
	void process() {
		std::cout << "Leaf：" << name << std::endl;
		//process current node
	}
};

void Invoke(Component& c) {
	//...
	c.process();
	//...
}

int main() {
	Composite root("root");
	Composite treeNode1("treeNode1");
	Composite treeNode2("treeNode2");
	Composite treeNode3("treeNode3");
	Composite treeNode4("treeNode4");
	Leaf leaf1("leaf1");
	Leaf leaf2("leaf2");

	root.add(&treeNode1);
	treeNode1.add(&treeNode2);
	treeNode2.add(&leaf1);

	root.add(&treeNode3);
	treeNode3.add(&treeNode4);
	treeNode4.add(&leaf2);

	Invoke(root);
}

运行结果：

在这里插入图片描述
结构示意图：
在这里插入图片描述
在这里插入图片描述

Iterator 迭代器

在这里插入图片描述
定义：
在这里插入图片描述
迭代器实现：

#include <iostream>
template<typename T>
class Iterator
{
public:
	~Iterator() {};
	virtual void first();
	virtual void next();
	virtual bool isDone() const;
	virtual T& current();
};

template<typename T>
class MyCollection {
public:
	Iterator<T> GetIterator() {
		//...
	}
};

template<typename T>
class CollectionIterator : public Iterator<T> {
	MyCollection<T> mc;
public:
	CollectionIterator(const MyCollection<T>& c) : mc(c) {}

	void first() override {
	}

	void next() override {
	}

	bool isDone() const override {
	
	}

	T& current() override {
	
	}
};

void MyAlgorithm() {
	MyCollection<int> mc;
	Iterator<int> iter = mc.GetIterator();

	for (iter.first(); !iter.isDone(); iter.next()) {
		//处理
		std::cout << iter.current() << std::endl;
	}
}

结构：
在这里插入图片描述

职责链

在这里插入图片描述
模式定义：
在这里插入图片描述
代码实现：

#include <iostream>
#include <string>

using namespace std;

enum class RequestType
{
	REQ_HANDLER1,
	REQ_HANDLER2,
	REQ_HANDLER3
};

//请求
class Request {
	std::string description;
	RequestType reqType;
public:
	Request(const std::string& desc, RequestType type) :description(desc), reqType(type) {}
	RequestType getType() const{ return reqType; }
	const std::string& getDescription() const { return description; }
};

//处理者  形成多态链表
class ChainHandler {
	ChainHandler* nextChain;
	void sendRequestToNextHandler(const Request& req) {
		if (nextChain != nullptr) {
			nextChain->handle(req);
		}
	}
protected:
	virtual bool canHandleRequest(const Request& req) = 0;
	virtual void processRequest(const Request& req) = 0;
public:
	ChainHandler() { nextChain = nullptr; }
	void setNextChain(ChainHandler* next) { nextChain = next; }

	void handle(const Request& req) {
		if (canHandleRequest(req)) {
			processRequest(req);
		}
		else {
			sendRequestToNextHandler(req);
		}
	}
};

class Handler1 :public ChainHandler {
protected:
	bool canHandleRequest(const Request& req) override {
		return req.getType() == RequestType::REQ_HANDLER1;
	}
	void processRequest(const Request& req) override {
		std::cout << "Handler1 is handling the request: " << req.getDescription() << std::endl;
	}
};

class Handler2 :public ChainHandler {
protected:
	bool canHandleRequest(const Request& req) override {
		return req.getType() == RequestType::REQ_HANDLER2;
	}
	void processRequest(const Request& req) override {
		std::cout << "Handler2 is handling the request: " << req.getDescription() << std::endl;
	}
};

class Handler3 :public ChainHandler {
protected:
	bool canHandleRequest(const Request& req) override {
		return req.getType() == RequestType::REQ_HANDLER3;
	}
	void processRequest(const Request& req) override {
		std::cout << "Handler3 is handling the request: " << req.getDescription() << std::endl;
	}
};

int main() {
	Handler1 h1;
	Handler2 h2;
	Handler3 h3;
	h1.setNextChain(&h2);
	h2.setNextChain(&h3);

	Request req("process task ...", RequestType::REQ_HANDLER3);
	h1.handle(req);
}

在这里插入图片描述

行为变化模式

在这里插入图片描述

命令模式

在这里插入图片描述
模式定义：
在这里插入图片描述
代码示例：

#include <string>
#include <iostream>
#include <vector>
using namespace std;

class Command {
public:
	virtual void execute() = 0;
};

class ConcreteCommand1 :public Command {
	string arg;
public:
	ConcreteCommand1(const string& a) : arg(a) {}
	void execute() override {
		cout << "#1 process..." << arg << endl;
	}

};

class ConcreteCommand2 :public Command {
	string arg;
public:
	ConcreteCommand2(const string& a) : arg(a) {}
	void execute() override {
		cout << "#2 process..." << arg << endl;
	}

};

class MacroCommand :public Command {
	vector<Command*> commands;
public:
	void addCommand(Command* c) { commands.push_back(c); }
	void execute() override {
		for (auto& c : commands) {
			c->execute();
		}
	}
};

int main() {
	ConcreteCommand1 command1("Arg ###");
	ConcreteCommand2 command2("Arg ...");

	MacroCommand macro;
	macro.addCommand(&command1);
	macro.addCommand(&command2);

	macro.execute();
}

结构：
在这里插入图片描述
总结：把行为封装成对象
在这里插入图片描述
原始代码：

class Vistor;

class Element {
public:
	virtual void Fun1() = 0;


	virtual ~Element() {}
};

class ElementA : public Element {
public:
	void Fun1() override {
		//...
	}
};

class ElementB : public Element {
public:
	void Fun1() override {
		//...
	}
};

需求增加：增加一个函数func2（int）

class Vistor;

class Element {
public:
	virtual void Fun1() = 0;
	virtual void Fun2(int data) = 0;

	virtual ~Element() {}
};

class ElementA : public Element {
public:
	void Fun1() override {
		//...
	}
	void Fun2(int data) override {
		//..
	}
};

class ElementB : public Element {
public:
	void Fun1() override {
		//...
	}
	void Fun2(int data) override {
		//..
	}
};

解析器

模式定义：
在这里插入图片描述

#include <iostream>
#include <string>
#include <map>
#include <stack>

using namespace std;

class Expression {
public:
	virtual int interpreter(map<char, int> var) = 0;
	virtual ~Expression() {};
};

//变量表达式
class VarExpression :public Expression {
	char key;
public:
	VarExpression(const char& key) {
		this->key = key;
	}
	int interpreter(map<char, int> var) override {
		return var[key];
	}
	~VarExpression() {}
};

//符号表达式
class SymbolExpression : public Expression {
	//运算符左右两个参数
protected:
	Expression* left;
	Expression* right;
public:
	SymbolExpression(Expression* left, Expression* right):left(left), right(right) 	{	}
	~SymbolExpression() {
		
	}
};

//加法运算
class AddExpression :public SymbolExpression {
public:
	AddExpression(Expression* left, Expression* right) :
		SymbolExpression(left, right) {}
	int interpreter(map<char, int> var) override {
		return left->interpreter(var) + right->interpreter(var);
	}
	~AddExpression() {}
};

//减法运算
class SubExpression :public SymbolExpression {
public:
	SubExpression(Expression* left, Expression* right) :
		SymbolExpression(left, right) {}
	int interpreter(map<char, int> var) override {
		return left->interpreter(var) - right->interpreter(var);
	}
	~SubExpression() {}
};

Expression* analyse(string expStr) {
	stack<Expression*> expStack;
	Expression* left = nullptr;
	Expression* right = nullptr;
	for(int i = 0; i < expStr.size(); ++i)
	{
		switch (expStr[i])
		{
			case '+':
				left = expStack.top();
				right = new VarExpression(expStr[++i]);
				expStack.push(new AddExpression(left, right));
				break;
			case '-':
				left = expStack.top();
				right = new VarExpression(expStr[++i]);
				expStack.push(new SubExpression(left, right));
				break;
			default:
				expStack.push(new VarExpression(expStr[i]));
				break;
		}
	}
	Expression* expression = expStack.top();
	return expression;
}

void release(Expression* expression) {
	//释放表达式树节点内存
}

int main() {
	string expStr = "a+b-c+d";
	map<char, int> var;
	var.insert(make_pair('a', 5));
	var.insert(make_pair('b', 2));
	var.insert(make_pair('c', 1));
	var.insert(make_pair('d', 6));

	Expression* exp = analyse(expStr);

	int res = exp->interpreter(var);

	std::cout << res << std::endl;
	
}

结构：
在这里插入图片描述
总结：
在这里插入图片描述

总结

核心：管理变化，提高复用！
八个设计原则！

zzh123353
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《C++ 设计模式》
青春不老，奋斗不止！
02-09 9万+
设计模式代表了最佳的实践，在面向对象的编程中被很多老鸟们反复使用。使用设计模式有很多好处：可重用代码、保证代码可靠性、使代码更易被他人理解 ......
C++设计模式（23种）汇总及代码实现
songbijian的博客
09-03 4287
它是继承复用的基石，只有当衍生类可以替换掉基类，软件单位功能不受到影响的时候，基类才能真正被复用，而衍生类也能够在积累的基础上增加新的行为。提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示。它结合了两个独立接口的功能，将一个类的接口转换成客户期望的另一个接口，让原本不兼容的类或者函数可以协同运作，是两个不兼容的接口之间的桥梁。3.当进行深拷贝的时候，需要编写较为复杂的代码，而且当对象之间存在多重嵌套时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现复杂。
c++ 设计模式类图
weixin_60569662的博客
06-12 1815
类图(Class diagram)是显示了模型的静态结构，特别是模型中存在的类、类的内部结构以及它们与其他类的关系等。类图不显示暂时性的信息。类图是面向对象建模的主要组成部分。它既用于应用程序的系统分类的一般概念建模，也用于详细建模，将模型转换成编程代码。类图(Class diagram)是显示了模型的静态结构，特别是模型中存在的类、类的内部结构以及它们与其他类的关系等。类图不显示暂时性的信息。类图是面向对象建模的主要组成部分。它既用于应用程序的系统分类的一般概念建模，也用于详细建模，将模型转换成编程代码。
C++设计模式总结
长期更新Java自学笔记
09-06 4443
一、单例模式 一个类不管常见多少次对象，永远只能得到该类型一个对象的实例 // p1、p2、p3指向同一对象 A* p1 = new A(); A* p2 = new A(); A* p3 = new A(); 饿汉式单例模式： 还没有获取实例对象，实例对象就已经产生了 优点：线程安全。对象存放在数据段，main函数还没有开始执行，对象就已经初始化好了，一定是线程安全的。 缺点： 获取在软件启动的时候，并没有使用到这个对象，然而这个对象已经产生，这就比较浪费资源。 #include<iostream
C++设计模式-组合模式
IT1995的博客
08-02 7008
目录 基本概念 代码与实例 基本概念 个人感觉Qt的对象树就是运用了这种设计模式！！！ 当然，只是个人感觉，本人并没有研究Qt的源码 组合模式（Composite）：将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。 何时使用：需求中提现部分和整体的层次结构，开发者希望用户忽略组合对象与单个对象的不同，统一使用...
C++ 设计模式之责任链模式
K1_uestc的博客
01-25 1461
-什么是责任链模式（第21种设计模式）责任链模式是⼀种行为型设计模式，它允许你构建⼀个对象链，让请求从链的⼀端进⼊，然后沿着链上的对象依次处理，直到链上的某个对象能够处理该请求为止。职责链上的处理者就是⼀个对象，可以对请求进⾏处理或者将请求转发给下⼀个节点，这个场景在⽣活中很常⻅，就是⼀个逐层向上递交的过程，最终的请求要么被处理者所处理，要么处理不了，这也因此可能导致请求⽆法被处理。【组成结构】1.处理者Handler：定义⼀个处理请求的接⼝，包含⼀个处理请求的抽象⽅法和⼀个指向下⼀个处理者的链接。
C++设计模式-外观模式
IT1995的博客
06-19 4838
目录 基本概念 代码与实例 基本概念 外观模式（Facade）：为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。 增加外观Facade可以提供一个简单的接口，减少它们之间的依赖； 为新系统开发一个外观Facade类，来提供设计粗糙或高度复杂的遗留代码的比较清晰简单的接口，让新系统与Facade对象交互，Facade...
C++设计模式-状态模式
热门推荐
IT1995的博客
07-05 1万+
目录 基本概念 代码与实例 基本概念 状态模式（State）：当一个对象的内在状态改变时允许改变其行为，这个对象看起来就像是改变了其类； 状态模式的好处： 1. 将与特定状态相关的行为局部化，并且将不同状态的行为分割开来； 2. 状态模式通过把各种状态转移逻辑分布到State的子类之间，来减少相互的依赖； 当一个对象的行为取决与他...
C++设计模式——策略模式(Strategy Pattern)
leonardohaig的博客
05-30 2459
C++设计模式——策略模式(Strategy Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——策略模式(Strategy Pattern)目录定义实现示例传统的策略模式实现使用函数指针实现策略模式工厂模式和策略模式对比总结参考资料 定义 Define a family of algorithms,encapsulate each one,and make them interchangeable. 定义一组算法，将每个算法都封装起来，并且使它们之间可以互换 策略模式是指定
C++设计模式.pdf
08-08
C++零基础学习设计模式，23种设计模式精讲，C++开发必备书籍，零基础轻松掌握，每种设计模式附加代码和uml框图！
C++设计模式学习框架
01-04
"C++设计模式学习框架"是一个专为学习和实践这些模式而构建的资源集合，它涵盖了各种常见的设计模式，帮助开发者深入理解并熟练应用到实际项目中。 设计模式通常分为三类：创建型模式（Creational Patterns）、结构...
c++ 设计模式代码
04-09
Bridge,Builder,Command,Composite,FactoryMethod,IStrategy,MultipleDocument,Proxy,SingleDocument,Singleton,TemplateMethod
C++设计模式-单实例
01-20
【C++设计模式-单实例】是C++编程中一种重要的设计模式，它涉及到软件设计中的对象创建和管理。设计模式是一种在特定场景下解决常见问题的模板，它基于前人的经验总结，使得代码可读性更强，也更易于重用。在C++中，...
c++ 设计模式
04-14
c++ 设计模式实现
C++设计模式精华版
08-03
"C++设计模式精华版"正是这样一个资源，它涵盖了多种在软件开发中常用的设计模式，帮助开发者深入理解并熟练运用这些模式。 设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。创建型模式关注对象的...
c++设计模式小例子
02-06
C++设计模式是一种在软件开发中经常使用的复用和组织代码的方法，它们是解决常见问题的模板或蓝图，可以提高代码的可读性、可维护性和可扩展性。本资源包含了一些C++实现的设计模式示例，对于初学者来说是非常宝贵的...
C++设计模式课程和源码
06-16
本资源包“C++设计模式课程和源码”包含了对C++设计模式的深入学习材料，同时涵盖STL（标准模板库）与泛型编程、算法、系统设计、内存管理和面向对象高级开发等多个方面的课程资料。 首先，关于C++设计模式，它们...
c++设计模式面试题
最新发布
06-24
C++设计模式是软件设计中常用的最佳实践，它们解决了一些常见的编程问题，并提供了可复用的解决方案。在面试中，关于C++设计模式的问题可能会涉及到以下几个方面： 1. **单例模式（Singleton）**：如何保证一个类只有一个实例并提供全局访问点？ 2. **工厂方法模式（Factory Method）**：何时使用，如何封装创建对象的过程？ 3. **观察者模式（Observer）**：如何实现对象之间的依赖关系，当一个对象状态改变时通知其他对象？ 4. **策略模式（Strategy）**：如何定义一组相关的算法，并使它们能够互换使用？ 5. **模板方法模式（Template Method）**：如何在不改变算法结构的情况下，允许子类重写特定步骤？ 6. **适配器模式（Adapter）**：如何让不兼容的接口协同工作？ 7. **装饰器模式（Decorator）**：如何动态地给一个对象增加功能，而又不改变其原有代码？ 面试时，你可能会被问到这些模式的应用场景、优缺点以及如何在实际项目中正确使用。相关问题可能包括：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值