C++设计模式---创建型模式

最新推荐文章于 2024-06-13 10:05:06 发布
最新推荐文章于 2024-06-13 10:05:06 发布
阅读量1k 收藏 8
点赞数 37
分类专栏： 设计模式 文章标签： 开发语言 C++ 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51647149/article/details/138950877
版权

创建型模式分类： 

1. 简单工厂模式 

1.1 简单工厂模式理论

1.2 简单工厂模式案例

代码示例： 

#include<iostream>
using namespace std;

//抽象水果
class AbstractFruit
{
public:
	virtual void ShowName() = 0;

};

//苹果
class Apple :public AbstractFruit
{
	virtual void ShowName()
	{
		cout << "我是苹果！" << endl;
	} 
};

//香蕉
class Banana :public AbstractFruit
{
	virtual void ShowName()
	{
		cout << "我是香蕉！" << endl;
	}
};

//鸭梨
class Pear :public AbstractFruit
{
	virtual void ShowName()
	{
		cout << "我是鸭梨！" << endl;
	}
};

//水果工厂
class FruitFactor {
public:
	static AbstractFruit* CreateFruit(string flag) {
		if (flag == "apple") 
		{
			return new Apple;
		}
		else if (flag == "banana") 
		{
			return new Banana;
		}
		else if (flag == "pear") 
		{
			return new Pear;
		}
		else 
		{
			return NULL;
		}
	}
};

void test05() 
{
	FruitFactor* factory = new FruitFactor;
	AbstractFruit* fruit = factory->CreateFruit("apple");
	fruit->ShowName();
	delete fruit;

	fruit = factory->CreateFruit("banana");
	fruit->ShowName();
	delete fruit;

	fruit = factory->CreateFruit("pear");
	fruit->ShowName();
	delete fruit;

	fruit = NULL;
	delete factory;
	factory = NULL;
}

int main()
{
	test05();
	return 0;
}

1.3 简单工厂模式的优缺点

优点：

        不需要记住具体类名，甚至连具体参数都不用记忆。
        实现了对象创建和使用的分离。
        系统的可扩展性也就变得非常好，无需修改接口和原类。

缺点：

        增加系统中类的个数，复杂度和理解度增加。
        增加了系统的抽象性和理解难度。

        违反“开闭原则”，添加新产品需要修改工厂逻辑，工厂越来越复杂。

1.4 简单工厂模式适用场景 

1. 工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。
2. 客户端只知道传入工厂类的参数，对于如何创建对象并不关心。

2. 工厂方法模式

2.1 工厂方法模式理论

 简单工厂模式＋"开闭原则"=工厂方法模式

2.2 工厂方法模式案例

代码示例： 

#include <iostream>
using namespace std;

//抽象水果
class AbstractFruit 
{
public:
	virtual void ShowName() = 0;
};

//苹果
class Apple :public AbstractFruit 
{
public:
	virtual void ShowName() 
	{
		cout << "我是苹果!" << endl;
	}
};

//香蕉
class Banana :public AbstractFruit 
{
public:
	virtual void ShowName() 
	{
		cout << "我是香蕉!" << endl;
	}
};

//鸭梨
class Pear :public AbstractFruit 
{
public:
	virtual void ShowName() 
	{
		cout << "我是鸭梨!" << endl;
	}
};

//抽象工厂
class AbstractFruitFactory 
{
public:
	virtual AbstractFruit* CreateFruit() = 0;
};


//苹果工厂
class AppleFactory :public AbstractFruitFactory 
{
public:
	virtual AbstractFruit* CreateFruit() 
	{
		return new Apple;
	}
};

//香蕉工厂
class BananaFactory :public AbstractFruitFactory 
{
public:
	virtual AbstractFruit* CreateFruit() 
	{
		return new Banana;
	}
};

//鸭梨工厂
class PearFactory :public AbstractFruitFactory 
{
public:
	virtual AbstractFruit* CreateFruit() 
	{
		return new Pear;
	}
};


void test05() 
{
	AbstractFruitFactory* factory = NULL;
	AbstractFruit* fruit = NULL;

	//创建一个苹果工厂
	factory = new AppleFactory;
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;

	//创建一个香蕉工厂
	factory = new BananaFactory;
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;

	//创建一个鸭梨工厂
	factory = new PearFactory;
	fruit = factory->CreateFruit();
	fruit->ShowName();
	delete fruit;
	delete factory;
	fruit = NULL;
	factory = NULL;

}

int main() 
{
	test05();
	return 0;
}

2.3 工厂方法模式适用场景

1. 客户端不知道它所需要的对象的类。
2. 抽象工厂类通过其子类来指定创建哪个对象。

2.4 工厂方法模式的总结 

传统：如果想创建两个苹果，得具体实例化两个，然后再调用功能，以后再用还得记名字

Apple a；
a.func();
Aplle b；
b.func();

工厂方法模式：可以不用具体一个对象，然后调用

factory = new AppleFactory;
fruit = factory->CreateFruit();//造a
fruit->ShowName();
fruit = factory->CreateFruit();//造b
fruit->ShowName();

3. 抽象工厂模式 

3.1 抽象工厂模式理论

3.2 抽象工厂模式案例 

#include <iostream>
using namespace std;

//抽象苹果
class AbstractApple 
{
public:
	virtual void ShowName() = 0;
};

//中国苹果
class ChinaApple :public AbstractApple 
{
public:
	virtual void ShowName() 
	{
		cout << "中国苹果！" << endl;
	}
};

//美国苹果
class USAApple :public AbstractApple 
{
public:
	virtual void ShowName() 
	{
		cout << "美国苹果！" << endl;
	}
};

//日本苹果
class JapanApple :public AbstractApple 
{
public:
	virtual void ShowName() 
	{
		cout << "日本苹果！" << endl;
	}
};

//抽象香蕉
class AbstractBanana 
{
public:
	virtual void ShowName() = 0;
};

//中国香蕉
class ChinaBanana :public AbstractBanana 
{
public:
	virtual void ShowName() 
	{
		cout << "中国香蕉！" << endl;
	}
};

//美国香蕉
class USABanan :public AbstractBanana 
{
public:
	virtual void ShowName() 
	{
		cout << "美国香蕉！" << endl;
	}
};

//日本香蕉
class JapanBanan :public AbstractBanana 
{
public:
	virtual void ShowName() 
	{
		cout << "日本香蕉！" << endl;
	}
};

//抽象鸭梨
class AbstractPear 
{
public:
	virtual void ShowName() = 0;
};


//中国鸭梨
class ChinaPear :public AbstractPear 
{
public:
	virtual void ShowName() 
	{
		cout << "中国鸭梨！" << endl;
	}
};

//美国鸭梨
class USAPear :public AbstractPear 
{
public:
	virtual void ShowName() 
	{
		cout << "美国鸭梨！" << endl;
	}
};

//日本鸭梨
class JapanPear :public AbstractPear 
{
public:
	virtual void ShowName() 
	{
		cout << "日本鸭梨！" << endl;
	}
};


//抽象工厂 针对产品族
class AbstractFactory 
{
public:
	virtual AbstractApple* CreateApple() = 0;
	virtual AbstractBanana* CreateBanana() = 0;
	virtual AbstractPear* CreatePear() = 0;
};

//中国工厂
class ChinaFactory :public AbstractFactory 
{
public:
	virtual AbstractApple* CreateApple() 
	{
		return new ChinaApple;
	}
	virtual AbstractBanana* CreateBanana() 
	{
		return new ChinaBanana;
	}
	virtual AbstractPear* CreatePear() 
	{
		return new ChinaPear;
	}
};

//美国工厂
class USAFactory :public AbstractFactory 
{
public:
	virtual AbstractApple* CreateApple() 
	{
		return new USAApple;
	}
	virtual AbstractBanana* CreateBanana() 
	{
		return new USABanan;
	}
	virtual AbstractPear* CreatePear() 
	{
		return new  USAPear;
	}
};

//日本工厂
class JapanFactory :public AbstractFactory 
{
public:
	virtual AbstractApple* CreateApple() 
	{
		return new JapanApple;
	}
	virtual AbstractBanana* CreateBanana() 
	{
		return new JapanBanan;
	}
	virtual AbstractPear* CreatePear() 
	{
		return new  JapanPear;
	}
};

void test06() 
{
	AbstractFactory* factory = NULL;
	AbstractApple* apple = NULL;
	AbstractBanana* banana = NULL;
	AbstractPear* pear = NULL;

	//中国工厂
	factory = new ChinaFactory;
	apple = factory->CreateApple();
	banana = factory->CreateBanana();
	pear = factory->CreatePear();

	apple->ShowName();
	banana->ShowName();
	pear->ShowName();
}

int main() 
{
	test06();
	return 0;
}

3.3 抽象工厂模式的优缺点

优点：
        拥有工厂方法模式的优点

        当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。

        增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。

缺点：
​        增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。

4. 单例模式 

4.1 单例模式理论

        单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

实现单例步骤：

1. 构造函数私有化
2. 增加静态私有的当前类的指针变量
3. 提供静态对外接口，可以让用户获得单例对象 

4.2 单例模式案例 

1.懒汉式(需要的时候才会创建)

2.饿汉式(直接创建，理解为main执行前，就创建好了)

#include <iostream>
using namespace std;


class A 
{
private:
	A() 
    {
		a = new A;
	}
public:
	static A* getInstance() 
    {
		return a;
	}
private:
	static A* a;
};


A* A::a = NULL;

//实现单例步骤
//1.构造函数私有化
//2.增加静态私有的当前类的指针变量
//3.提供静态对外接口，可以让用户获得单例对象

//单例 分为懒汉式 饿汉式

//1.懒汉式(需要的时候才会创建)
class Singleton_lazy 
{
private:
	Singleton_lazy() 
    { 
        cout << "我是懒汉构造！" << endl; 
    }
public:
	static Singleton_lazy* getInstance() 
    {
		if (pSingleton == NULL)
        {
			pSingleton = new Singleton_lazy;
		}
		return pSingleton;
	}
private:
	static Singleton_lazy* pSingleton;
};

//类外初始化
Singleton_lazy* Singleton_lazy::pSingleton = NULL;

//2.饿汉式
class Singleton_hungry 
{
private:
	Singleton_hungry() 
    { 
        cout << "我是饿汉构造！" << endl; 
    }
public:
	static Singleton_hungry* getInstance() 
    {
		return pSingleton;
	}
private:
	static Singleton_hungry* pSingleton;
};

//类外初始化
Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry;

void test01() 
{
	Singleton_lazy* p1 = Singleton_lazy::getInstance();
	Singleton_lazy* p2 = Singleton_lazy::getInstance();
	if (p1 == p2) 
    {
		cout << "两个指针指向同一块内存空间，是单例！" << endl;
	}
	else 
    {
		cout << "不是单例模式！" << endl;
	}

	Singleton_hungry* p3 = Singleton_hungry::getInstance();
	Singleton_hungry* p4 = Singleton_hungry::getInstance();
	if (p3 == p4) 
    {
		cout << "两个指针指向同一块内存空间，是单例！" << endl;
	}
	else 
    {
		cout << "不是单例模式!" << endl;
	}
}


int main() 
{
	//A a; // 或A*a=new A;  这两个会调用构造函数，要让不能构造函数
	//A::getInstance();

	test01();
	cout << "main函数开始执行！" << endl;

	return 0;
}

4.3  单例对象释放(不考虑内存释放问题)

1. 单例对象从头到尾就一份内存，没必要释放

2. 如果非要提供释放，可以如下，运行完自动释放：

#include <iostream>
using namespace std;

//实现单例步骤
//1.构造函数私有化
//2.增加静态私有的当前类的指针变量
//3.提供静态对外接口，可以让用户获得单例对象

//单例 分为懒汉式 饿汉式

//1.懒汉式(需要的时候才会创建)
class Singleton_lazy 
{
private:
	Singleton_lazy() 
	{ 
		cout << "我是懒汉构造！" << endl; 
	}
public:
	static Singleton_lazy* getInstance() 
	{
		if (pSingleton == NULL) 
		{
			pSingleton = new Singleton_lazy;
		}
		return pSingleton;
	}
#if 0 
	//这样释放不行，万一谁手贱释放，就直接没了，这个权限不能给
	static void freeSpace() 
	{
		if (pSingleton != NULL) 
		{
			delete pSingleton;
		}
	}
#endif
	//如果非要写，可以加个这个，运行完自动释放
	class Garbo 
	{
		Garbo() 
		{
			if (pSingleton != NULL) 
			{
				delete pSingleton;
			}
		}
	};

private:
	static Singleton_lazy* pSingleton;
	static Garbo garbo;
};

//类外初始化
Singleton_lazy* Singleton_lazy::pSingleton = NULL;

//2.饿汉式
class Singleton_hungry 
{
private:
	Singleton_hungry() 
	{ 
		cout << "我是饿汉构造！" << endl; 
	}
public:
	static Singleton_hungry* getInstance() 
	{
		return pSingleton;
	}
private:
	static Singleton_hungry* pSingleton;
};

//类外初始化
Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry;

void test07() 
{
	Singleton_lazy* p1 = Singleton_lazy::getInstance();
	Singleton_lazy* p2 = Singleton_lazy::getInstance();
	if (p1 == p2) 
	{
		cout << "两个指针指向同一块内存空间，是单例！" << endl;
	}
	else 
	{
		cout << "不是单例模式！" << endl;
	}

	Singleton_hungry* p3 = Singleton_hungry::getInstance();
	Singleton_hungry* p4 = Singleton_hungry::getInstance();
	if (p3 == p4) 
	{
		cout << "两个指针指向同一块内存空间，是单例！" << endl;
	}
	else 
	{
		cout << "不是单例模式!" << endl;
	}
}

#if 0
void test07_1() 
{
	Singleton_lazy::freeSpace();
}
#endif

int main() 
{

	test07();
	cout << "main函数开始执行！" << endl;
	return 0;
}

4.4 单例模式遇到多线程 

        懒汉式碰到多线程是线程不安全的，比如下班两个都判别pSingleton ==NULL，都创建一个，就不是单例了。

        使用懒汉式需要自己加锁并且解锁，步骤繁琐，推荐使用饿汉式。

4.5 单例模式的优缺点 

优点：

        单例模式提供了对唯一实例的受控访问

        节约系统资源。由于在系统内存中只存在一个对象。

缺点：

        扩展略难。单例模式中没有抽象层。

        单例类的职责过重。

4.6 单例模式适用场景 

1. 系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器（像windows的资源管理器），或者需要考虑资源消耗太大而只允许创建一个对象。

2. 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。

菜就多练wwww
关注
  • 37
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++设计模式-创建型模式-建造者模式
06-04
c++设计模式-创建型模式-建造者模式-qt工程源码，c++实现
c++设计模式-工厂方法模式
06-04
c++设计模式-创建型模式-工厂方法模式-最简单的源码-qt工程
3.C++设计模式-创建型模型
weixin_42636062的博客
08-26 2982
3.C++设计模式-工厂模式 3.1 简单工厂模式 3.1.1 理论 3.1.2 简单工厂模式案例 不难看出，Fruit类是一个“巨大的”类，在该类的设计中存在如下几个问题： (1) 在Fruit类中包含很多“if…else…”代码块，整个类的代码相当冗长，代码越长，阅读难度、维护难度和测试难度也越大；而且大量条件语句的存在还将影响系统的性能，程序在执行过程中需要做大量的条件判断。 (2) Fruit类的职责过重，它负责初始化和显示所有的水果对象，将各种水果对象的初始化代码和显示代码集中在一个类中实现
C++设计模式 - 创建型模式之工厂模式
kakaka666的博客
06-11 1585
工厂模式最直观的理解是，减少new创建对象的方式，用接口的方式来返回一个对象，而new创建的方式被封装了简单工厂：调用者只需使用单例工厂就可获取同一范畴的所有产品工厂方法：调用者并不知道它在运行时会获取何种产品，只知道某个特定的工厂能生成出满足需求的产品抽象工厂：调用者可以在运行时从特定的工厂中获得所有信息相关的产品簇(可以对产品进行组合)
C++创建型模式-原型模式
灰太狼的小秘密
08-29 1712
参考文献： 【1】
23种设计模式 - C++实现
阿呆的隐秘角落
08-07 4000
23种设计模式
C++创建型模式-建造者模式
灰太狼的小秘密
09-03 1664
1.1 基本概念 建造者模式（Builder）: 将一个复杂对象的构建与它的表示分离，使得同样的构建过程就可以创建不同的表示。 1.2 定义方式 1.3 优缺点 1.4 应用场景 1.5 实现方式 参考文献： 【1】 ............
5.C++设计模式-行为型模型
weixin_42636062的博客
08-29 1681
5.C++设计模式-行为型模型 用来对类或对象怎样交互和怎样分配职责进行描述。 5.1 模板方法模式 5.1.1 模板方法的理论 ​ 定义一个操作中算法的框架，而将一些步骤延迟到子类中。模板方法模式使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 5.1.2 模板方法的案例 #include <iostream> using namespace std; class DrinkTemplate { public: //注水 virtual void Boildwate
c++设计模式--简单工厂模式
u013083044的博客
12-16 875
简单工厂模式
C++创建型模式-工厂模式
热门推荐
灰太狼的小秘密
08-26 1万+
一、基础知识 1.1 简单工厂模式 简单工厂模式（Simple Factory Pattern）专门定义一个类来负责创建其他类的实例，被创建的实例通常具有共同的父类。 1.2 简单工厂模式的角色 二、C++实现工厂模式 参考文献： 【1】 ......
C++创建型模式-单例模式实现
灰太狼的小秘密
02-27 2025
一、单例模式 1.1 基本概念 单例 Singleton 是设计模式的一种，其特点是只提供唯一一个类的实例,具有全局变量的特点，在任何位置都可以通过接口获取到那个唯一实例; 保证一个类仅有一个实例； 并提供一个访问它的全局访问点； 该实例被所有程序模块所共享。 1.2 应用场景 设备管理器，系统中可能有多个设备，但是只有一个设备管理器，用于管理设备驱动; 数据池，用来缓存数据的数据结构，需要在一处写，多处读取或者多处写，多处读取; Windows资源管理器 1.3 定义方式 定..
c++设计模式-抽象工厂方法
06-04
c++设计模式-创建型-抽象工厂方法-最简单源码-qt工程
c++设计模式-结构型模式-享元模式
06-15
c++设计模式-结构型模式-享元模式；qt工程；c++简单源码； 享元（Flyweight）模式的定义：运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类...
c++设计模式-单例模式
06-03
c++设计模式-创建型模式-单例模式源码，懒汉式 饿汉式源码，qt工程，单例模式线程安全问题，单例模式实现方式
二开版视频CMS完整运营源码/新版漂亮APP手机模板/集成员分销功能等
最新发布
jiyc2008的博客
06-13 532
【亲测二开版】麻豆影视CMS完整运营源码/2021新版漂亮APP手机模板/超强会员分销功能及多种会员租/对接免签约支付接口/送火车头模块/带文字搭建教程
为什么选择Python作为AI开发语言
AI心易行者
06-09 1555
综上所述，Python因其简洁易读的语法、丰富的库和框架、广泛的社区支持、适合快速原型开发的特性以及良好的兼容性和集成性，成为AI开发的首选语言。而像PlugLink这样的工具，则进一步提升了Python在AI开发中的效率和便利性。对于任何希望在AI领域有所作为的开发者来说，掌握Python无疑是必不可少的技能。在未来，随着AI技术的不断发展和进步，Python必将继续扮演重要角色，推动这一领域的创新和变革。如果你还没有开始学习Python，那么现在就是最好的时机。
C++中的单例模式
GOLOJO的博客
06-11 529
单例模式，通过确保类的唯一实例来简化资源管理，并在多个场景中广泛应用，如配置管理、日志记录和数据库连接池。
设计模式-建造者模式
Sun的个人博客
06-10 467
*** Description: 抽象的建造房屋的类*/// 打地基// 砌墙// 封顶// 造房子roofed();/*** Description: 产品*/
c++设计模式--基于qt4开源跨平台开发框架 pdf
10-13
其次，工厂模式是常用的创建型设计模式，它可以帮助开发者根据需要创建不同类型的PDF文件。例如，可以使用工厂模式创建基本的PDF文件、加密的PDF文件或者带有水印的PDF文件。 再次，装饰器模式是一种结构型设计模式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值