设计模式（C++）

最新推荐文章于 2024-06-18 09:38:17 发布
最新推荐文章于 2024-06-18 09:38:17 发布
阅读量164 收藏
点赞数
分类专栏： C++八股文 文章标签： c++ 设计模式 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013183558/article/details/128396635
版权

单例模式

单例模式（Singleton Pattern）的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。
单例模式有三个特点：

  1. 单例类只有一个实例对象；
  2. 单例对象必须由单例类自行创建；
  3. 单例类对外提供一个访问该单例的全局访问点；

懒汉单例

所谓懒汉，就是用的时候才会创建单例。为了避免多线程可能创建多份实例的问题，可以在创建实例时加上锁。另外，如果单例对象是指针时，还应该考虑其释放的问题。以下代码使用了智能指针，会管理指针的释放问题。为了隐藏析构函数（不让外部手动析构指针），也增加了指针管理类SingleDeletor。

//SingleLazy.h
#pragma once

#include <mutex>
#include <string>

class SingleLazy;
class SingleDeletor
{
public:
	void operator()(SingleLazy* single)
	{
		delete single;
	}
};

class SingleLazy
{
	SingleLazy() = default;
	~SingleLazy() {}
	SingleLazy(const SingleLazy&) = delete;
	SingleLazy& operator=(const SingleLazy&) = delete;

	static std::mutex m_mutex;
	static std::shared_ptr<SingleLazy> m_ptrSingle;

	friend class SingleDeletor;

public:
	static std::shared_ptr<SingleLazy> singleton()
	{
		if (m_ptrSingle == NULL)
		{
			m_mutex.lock();
			if (m_ptrSingle == NULL)
				m_ptrSingle = std::shared_ptr<SingleLazy>(new SingleLazy,SingleDeletor());
			m_mutex.unlock();
		}

		return m_ptrSingle;
	}

	std::string getString()
	{
		return "SingleLazy";
	}
};

std::mutex SingleLazy::m_mutex;
std::shared_ptr<SingleLazy> SingleLazy::m_ptrSingle;

饿汉单例

在类加载的时候就将单例实例创建好，所以多线程调用时没有问题，但是存在浪费内存的问题。

//SingleHungry.h
#pragma once

class SingleHungry
{
	SingleHungry() = default;
	SingleHungry(const SingleHungry&) = delete;
	SingleHungry& operator=(const SingleHungry&) = delete;

	static std::shared_ptr<SingleHungry> m_ptrSingle;

public:
	static std::shared_ptr<SingleHungry> singleton()
	{
		if (m_ptrSingle == NULL)
			m_ptrSingle = std::shared_ptr<SingleHungry>(new SingleHungry);

		return m_ptrSingle;
	}

	std::string getString()
	{
		return "SingleHungry";
	}
};

std::shared_ptr<SingleHungry> SingleHungry::m_ptrSingle = SingleHungry::singleton();

测试代码

//main.cpp
#include "SingleLazy.h"
#include "SingleHungry.h"

using namespace std;

int main()
{
	cout << SingleLazy::singleton()->getString() << endl;

	cout << SingleHungry::singleton()->getString() << endl;

	cout << "Hello CMake." << endl;
	return 0;
}

工厂模式

工厂模式（Factory Pattern）用一个简单的类来创建实例的过程便称为工厂，用工厂方式代替外部new操作的一种设计模式。这是一种创建型模式，它提供了一个创建对象的最佳方式。在工厂模式中，我们创建对象时不会对上层暴露创建逻辑，而是通过使用一个共同结构来指向新创建的对象。

简单工厂

有一个工厂，可以生产自行车、摩托车、小汽车。


class Product
{
public:
	Product() {}
	virtual ~Product() {}
	virtual std::string produceDate()
	{
		return "2022/01/01";
	}
};

class Bicycle :public Product
{
public:
	Bicycle() {}
};

class Motorcycle :public Product
{
public:
	Motorcycle() {}
};

class Car :public Product
{
public:
	Car() {}
};

class SimpleFactory
{
public:
	enum ProductType
	{
		eBicycle = 0,	///< 自行车
		eMotorcycle,	///< 摩托车
		eCar			///< 汽车
	};

public:
	static Product* createProduct(ProductType type)
	{
		switch (type) {
		case eBicycle:
			return new Bicycle();
		case eMotorcycle:
			return new Motorcycle();
		case eCar:
			return new Car();
		default:
			break;
		}
		return nullptr;
	}
};

方法工厂

为了提高产能，将小汽车、摩托车、自行车拆分成单独的产线，形成单独的工厂。

#pragma once

#include <iostream>
using namespace std;

class Product
{
public:
	Product() {}
	virtual ~Product() {}
	virtual std::string produceDate()
	{
		return "2022/01/01";
	}
};

class Bicycle :public Product
{
public:
	Bicycle() {}
};

class Motorcycle :public Product
{
public:
	Motorcycle() {}
};

class Car :public Product
{
public:
	Car() {}
};

class Factory
{
public:
	virtual Product* createProduct() = 0;
};

class BicycleFactory :public Factory
{
public:
	BicycleFactory() {}
	
	virtual Product* createProduct() 
	{
		std::cout << "create a bicycle" << std::endl;
		return new Bicycle();
	}
};

class MotorcycleFactory :public Factory
{
public:
	MotorcycleFactory() {}

	virtual Product* createProduct()
	{
		std::cout << "create a motorcycle" << std::endl;
		return new Motorcycle();
	}
};

class CarFactory :public Factory
{
public:
	CarFactory() {}

	virtual Product* createProduct()
	{
		std::cout << "create a car" << std::endl;
		return new Car();
	}
};

int main()
{
	CarFactory carFac;
	Car* pCar = dynamic_cast<Car*>(carFac.createProduct());

	return 0;
}

抽象工厂

行李箱生意市场前景可观，为了避免重新建厂，在现有三个厂的基础上，增加产线。自行车厂生产自行车和自行车行李箱、摩托车厂生产摩托车和摩托车行李箱、汽车厂生产汽车和汽车行李箱。

#pragma once

#include <iostream>
using namespace std;

class Product
{
public:
	Product() {}
	virtual ~Product() {}
	virtual std::string produceDate()
	{
		return "2022/01/01";
	}
};

class Bicycle :public Product
{
public:
	Bicycle() {}
};

class Motorcycle :public Product
{
public:
	Motorcycle() {}
};

class Car :public Product
{
public:
	Car() {}
};

//行李箱
class Cass
{
public:
	Cass() {}
	virtual ~Cass() {}
	virtual std::string produceDate()
	{
		return "2022/01/01";
	}
};

class BicycleCass :public Cass
{
public:
	BicycleCass() {}
};

class MotorcycleCass :public Cass
{
public:
	MotorcycleCass() {}
};

class CarCass :public Cass
{
public:
	CarCass() {}
};

class Factory
{
public:
	virtual Product* createProduct() = 0;
	virtual Cass* createCass() = 0;
};

class BicycleFactory :public Factory
{
public:
	BicycleFactory() {}
	
	virtual Product* createProduct() 
	{
		std::cout << "create a bicycle" << std::endl;
		return new Bicycle();
	}

	virtual Cass* createCass()
	{
		std::cout << "create a bicyclecass" << std::endl;
		return new BicycleCass();
	}
};

class MotorcycleFactory :public Factory
{
public:
	MotorcycleFactory() {}

	virtual Product* createProduct()
	{
		std::cout << "create a motorcycle" << std::endl;
		return new Motorcycle();
	}

	virtual Cass* createCass()
	{
		std::cout << "create a motorcyclecass" << std::endl;
		return new MotorcycleCass();
	}
};

class CarFactory :public Factory
{
public:
	CarFactory() {}

	virtual Product* createProduct()
	{
		std::cout << "create a car" << std::endl;
		return new Car();
	}

	virtual Cass* createCass()
	{
		std::cout << "create a carcass" << std::endl;
		return new CarCass();
	}
};

int main()
{
	CarFactory carFac;
	Car* pCar = dynamic_cast<Car*>(carFac.createProduct());
	CarCass* pCarCass = dynamic_cast<CarCass*>(carFac.createCass());

	return 0;
}

观察者模式

观察者模式（Observer Pattern）定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动的更新自己。

#pragma once

#include <iostream>
#include <list>
using namespace std;

class Observe
{
public:
	Observe() {}
	void update() 
	{
		std::cout << "update" << std::endl;
	}
};


class Subject
{
public:
	Subject() {}
	~Subject()
	{
		for (auto it : m_listObserve)
			delete it;
	}
	
	void attach(Observe* obs)
	{
		m_listObserve.emplace_back(obs);
	}

	void detach(Observe* obs)
	{
		m_listObserve.remove(obs);
	}

	void notify()
	{
		for (auto it : m_listObserve)
		{
			it->update();
		}
	}

private:
	std::list<Observe*> m_listObserve;
};

int main()
{
	Subject* pSubject = new Subject();
	pSubject->attach(new Observe());
	pSubject->attach(new Observe());

	pSubject->notify();
	delete pSubject;
	return 0;
}

装饰器模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

#pragma once

#include <iostream>
#include <list>
using namespace std;

class Cake
{
public:
	virtual void show() = 0;
};

//奶油蛋糕
class CreamCake :public Cake
{
public:
	virtual void show()
	{
		std::cout << "this is a CreamCake";
	}
};

//水果蛋糕
class FruitCake :public Cake
{
public:
	virtual void show()
	{
		std::cout << "this is a FruitCake";
	}
};


//巧克力装饰
class ChocolateCake :public Cake 
{
public:
	ChocolateCake(Cake* cake)
	{
		m_pCake = cake;
	}

	virtual void show()
	{
		m_pCake->show();

		std::cout << " add Chocolate on it";
	}

private:
	Cake* m_pCake = nullptr;
};

class CandyCake : public Cake
{
public:
	CandyCake(Cake* cake)
	{
		m_pCake = cake;
	}

	virtual void show()
	{
		m_pCake->show();

		std::cout << " add Candy on it";
	}

private:
	Cake* m_pCake = nullptr;
};


int main()
{
	Cake* pCreamCake = new CreamCake();			//先制作一个奶油蛋糕
	pCreamCake = new ChocolateCake(pCreamCake);	//添加巧克力
	pCreamCake->show();

	std::cout << std::endl;

	Cake* pFruitCake = new FruitCake();			//先制作一个水果蛋糕
	pFruitCake = new ChocolateCake(pFruitCake);	//添加巧克力
	pFruitCake = new CandyCake(pFruitCake);		//添加糖果
	pFruitCake->show();

	return 0;
}


输出结果：给奶油蛋糕添加了巧克力，给水果蛋糕添加了巧克力和糖果

MissingMe__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++设计模式
02-21
火龙果软件工程技术中心C++设计模式之Adapter一、功能　　将一个类的接口转换成客户希望的另外一个接口，解决两个已有接口之间不匹配的问题。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。二、结构图(1)classadapter(2)objectadapter三、实现和其他很多模式一样，学习设计模式的重点是学习每种模式的思想，而不应拘泥于它的某种具体结构图和实现。因为模式是灵活的，其实现可以是千变万化的，只是所谓万变不离其宗。在STL中大量运用了Adapter模式，象functionadapter、iteratoradpter，它们与这里说的adapter结构并不
C++设计模式（全23种）
weixin_45712636的博客
04-27 5万+
设计模式概述 设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。等这种思想融入到了思想中后，你就会不自觉地使用这种思想去进行你的设计和开发。 文章目录设计模式概述一、创建型模式Factory 模式（工厂模式）AbstactFactory 模式（抽象工厂模式）Singleton 模式（ 单例模式）Builder 模式（建造者模式）Prototype 模式（原型模式）二、结构型模式Bridge 模式（桥接模式）总结
C++ 设计模式
最新发布
wy749929317的博客
06-18 512
在C++中，设计模式（Design Patterns）是用于解决在软件设计中经常遇到的一些通用问题的最佳实践。这些设计模式是在多年的软件开发过程中积累下来的经验和智慧的结晶。定义一个操作中的算法的框架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。将一个类的接口转换成客户端所期望的另一种接口，从而使得原本由于接口不兼容而无法一起工作的类能够一起工作。将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
3.C++设计模式-创建型模型
weixin_42636062的博客
08-26 3031
3.C++设计模式-工厂模式 3.1 简单工厂模式 3.1.1 理论 3.1.2 简单工厂模式案例 不难看出，Fruit类是一个“巨大的”类，在该类的设计中存在如下几个问题： (1) 在Fruit类中包含很多“if…else…”代码块，整个类的代码相当冗长，代码越长，阅读难度、维护难度和测试难度也越大；而且大量条件语句的存在还将影响系统的性能，程序在执行过程中需要做大量的条件判断。 (2) Fruit类的职责过重，它负责初始化和显示所有的水果对象，将各种水果对象的初始化代码和显示代码集中在一个类中实现
c++设计模式
农家小院
10-28 1186
设计模式之c++
C++几种常用设计模式
qq_46423987的博客
09-05 1万+
设计模式
设计模式（一）（C++）
m0_51908955的博客
08-29 296
设计模式（一） 1.单例模式 定义 单例模式就是一个类只能被实例化一次 ，更准确的说是只能有一个实例化的对象的类。 这个类只能有一个实例（只有在指针为空时创建新对象，否则返回原有对象）； 它必须自己创建这个实例（构造函数为私有，然后通过getInstance方法间接访问）； 它必须自己向整个系统提供这个实例（getInstance为静态成员函数）。 注意：若为多线程环境，创建实例时需要用互斥锁加以保护。 #include <iostream> #include <mutex>
设计模式（C++实例）
菜鸟502的博客
08-13 1万+
感言 本文很长，但文中近乎有十之八九只能算是我在拜读各位大神大牛们分享的作品的笔记，这里只是我第一遍学习，我知道过了几天我肯定又会把看过的东西给忘记，所以就索性把各位大牛们的东西整理到了一起，方便以后的学习。1.（Strategy策略模式） 一个策略放到一个锦囊里。当用的时候，找到这个锦囊，从锦囊里拿出策略来使用。 注意：锦囊只是简单的装载和调用策略，锦囊里没有逻辑。策略会有更大的自主权，运行
设计模式Ｃ＋＋
06-05
"设计模式C++"这个主题涵盖了如何在C++环境中应用这些模式，帮助开发者构建更加高效、灵活的系统。 "HeadFirstDesignPatterns"这个文件名可能是指一本著名的书籍，书中详细介绍了多种设计模式，并以易于理解的方式...
18种设计模式c++版
04-12
在C++编程中，设计模式的应用能够提高代码的可读性、可维护性和可复用性。本资源包含18种经典的设计模式，每种模式都有详细的介绍、对应的C++代码实现以及UML（统一建模语言）图，帮助开发者更好地理解和应用这些...
C++ Design Pattern 23种设计模式(全_解释+源代码).zip
01-16
C++ 23种设计模式(全_解释+源代码).zip 23种设计模式都是基于以下原则,务必记牢 依赖倒转原则 里氏代换原则 开闭原则 接口隔离原则 合成聚合复用原则 迪米特法则 23种设计模式如下:
DesignPattern_设计模式c++_
10-04
本资源"DesignPattern_设计模式c++_"是一个关于C++设计模式的简单实现集合，适合初学者作为入门教程来学习。 1. **单例模式（Singleton）**：保证一个类只有一个实例，并提供全局访问点。在C++中，通常通过私有化...
C++设计模式（建议收藏）
qq_56999918的博客
10-04 1683
如果在多线程环境下线程一判断完这个_inst为空由于时间片的原因被切走了，此时线程二进来发现为空创建了对象，当线程一再次被切回来的时候，继续往下执行又创建了一份对象此时和我们预期的就不一样了。单例模式是指在内存当中只会创建一次对象的设计模式，有时候在一个程序当中多次使用一个对象并且作用相同时，此时如果创建多个对象是非常的浪费内存的，单例模式可以让对象在内存当中只被创建一份。单例模式在面试当中也是考察的非常多的一个设计模式，在面试当中需要我们掌握的是场景的两种一种是懒汉模式，一种是饿汉模式。
《C++ 设计模式》
热门推荐
青春不老，奋斗不止！
02-09 9万+
设计模式代表了最佳的实践，在面向对象的编程中被很多老鸟们反复使用。使用设计模式有很多好处：可重用代码、保证代码可靠性、使代码更易被他人理解 ......
程序开发的23种模式
u013430241的博客
07-28 694
一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 其实还有两类
C++设计模式总结
长期更新Java自学笔记
09-06 4455
一、单例模式 一个类不管常见多少次对象，永远只能得到该类型一个对象的实例 // p1、p2、p3指向同一对象 A* p1 = new A(); A* p2 = new A(); A* p3 = new A(); 饿汉式单例模式： 还没有获取实例对象，实例对象就已经产生了 优点：线程安全。对象存放在数据段，main函数还没有开始执行，对象就已经初始化好了，一定是线程安全的。 缺点： 获取在软件启动的时候，并没有使用到这个对象，然而这个对象已经产生，这就比较浪费资源。 #include<iostream
c++—设计模式
m0_72814368的博客
06-05 2562
c++—设计模式
C++23种设计模式&软件设计模型
m0_74036006的博客
01-24 1628
3.适配器模式就是将原来开发的接口对于用户不符 然后转换成用户 所期待的接口 这样可以避免因改动整个代码而产生时间损失 精力损失 财富损失 而改变一个接口可以很好的提高企业开发的效率。其他类型的模式： 在某些分类中，还会提到一些其他类型的模式，例如： ————并发性模式：如生产者-消费者、读写锁等。适配器（Adapter）：连接目标接口和被适配者的中间类，实现了目标接口，并持有被适配者对象，以便将请求转发给被适配者。配器模式是一种结构设计模式，它用于将一个类的接口转换成客户端所期望的另一个接口。
设计模式c++ pdf
06-22
### 回答1： 设计模式c pdf 是一本介绍常用设计...总之，设计模式C++PDF是一本非常值得学习的书籍，里面介绍的设计模式已经得到了许多开发者的验证和应用，可以帮助读者更好地理解设计模式的思想并在实践中有效地应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值