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

最新推荐文章于 2024-10-31 17:24:07 发布
最新推荐文章于 2024-10-31 17:24:07 发布
阅读量1.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
关注
专栏目录
c++设计模式-创建型模式-建造者模式
06-04
**建造者模式（Builder Pattern）**是软件设计模式中的一种创建型模式，它允许我们分步骤构建复杂的对象，而无需暴露构建过程。在C++中，这种模式常用于将对象的创建过程与使用过程分离，使得对象的构建更加灵活，...
C++设计模式--基于Qt4开源跨平台开发框架
01-06
创建型模式如单例模式（Singleton）、工厂模式（Factory Method）和抽象工厂模式（Abstract Factory），主要关注对象的创建过程，旨在减少类之间的耦合度。结构型模式如适配器模式（Adapter）、装饰器模式...
C++设计模式之创建型模式
maobin_1的博客
11-20 172
1、单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供一个访问它的全局访问点。例如，在一个多线程程序中，使用单例模式可以确保只有一个线程访问某个资源。C++设计模式的创建型模式可以分为单例模型、简单工厂模式、工厂方法模式、抽象工厂模式、原型模式、建造者模式。
《C++设计模式》——创建型
小小博客
09-07 556
前言 Factory Method(工厂模式) Abstract Factory(抽象工厂) Builder(建造者) Prototype(原型) Singleton(单例) 后记
C++ 设计模式——创建型模式
y734564892的博客
06-12 1139
&lt;strong&gt;创建型模式：&lt;br&gt;源码点击[这里 go to Github](https://github.com/bob-young/CPPDesignPattern "点击") .&lt;br&gt;&lt;li&gt;Singleton&lt;br&gt;&lt;p&gt;特点：确保一个类只有一个实例，自行实例化，并向整个系统提供该实例&lt;br&am
c++创建型设计模式--工厂模式--抽象工厂（多个产品的构建--系列）
riversky的博客
10-12 383
在基类CarBase基础上进行构建 基类 #pragma once #include &lt;iostream&gt; /** * 基类指针 *Date :[10/12/2018 ] *Author :[RS] */ class CarBase { public: virtual ~CarBase() { std::cout &lt;&lt; "析构 carBase" &lt;&...
c++设计模式详解_创建型设计模式
weixin_46935110的博客
07-17 2738
c++设计模式详解_创建型设计模式
c++设计模式-工厂方法模式
06-04
描述中的“创建型模式-工厂方法模式-最简单的源码-qt工程”表明，这个压缩包可能包含了一个基于Qt框架的C++项目，该项目展示了工厂方法模式的简单应用。Qt是一个跨平台的应用程序开发框架，广泛用于GUI编程，但也...
c++设计模式-结构型模式-享元模式
06-15
c++设计模式-结构型模式-享元模式；qt工程；c++简单源码； 享元（Flyweight）模式的定义：运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类...
c++设计模式-行为型模式-迭代器模式
06-25
迭代器模式是软件设计模式中的一种行为模式，它在C++以及其他面向对象编程语言中有着广泛的应用。这个模式的主要目标是允许用户以一种统一的方式遍历聚合对象中的元素，而无需暴露聚合对象的内部结构。这增加了代码...
C++设计模式（一）——创建型模式
lincccbb的博客
07-03 260
设计模式指导我们怎样去创建、维护、分配面向对象系统中的实体类，以获得高内聚、低耦合的面向对象系统，从而提高系统的可维护性和可复用性。设计模式是OO的一些设计思想的一个总结（但不是全部），因此设计模式和OO的设计原则经验没有矛盾，而是殊途同归。 一、创建型模式 1、Factory模式         Factory模式的两个最重要的功能：       1）定义创建对象的接
设计模式以及C++实现(一)创建型模式
hhwhg123的博客
08-23 330
目录 入门之简单工厂 功能： 类图： C++代码简单实现： 工厂方法 功能： 类图： 代码： 抽象工厂 功能： 类图： 代码： 单例模式 功能： 类图： 代码： 原型模式 功能： 类图： 代码： 建造者模式 功能： 类图 代码： 入门之简单工厂 功能： 定义创建对象的接口，封装了对象的创建 类图： C++代码简单实现： #in...
C++设计模式——创建型模式之建造者模式（Builder）
qq_25065595的博客
09-03 280
创建型模式之建造者模式（Builder） 建造者模式（Builder）将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 Builder：抽象的创造者，为创建一个产品对象的各个部件指定抽象的接口； ConcreteBuilder：具体建造者，实现抽象Builder定义的接口来完成产品的各个部件的创建。 Director：指挥者，它是一个使用Builder接口的对象； Product：具体的产品对象。 代码框架 #include <iostream> #
设计模式奇才：掌握创建型设计模式的核心技巧
Lion_Long的博客
09-27 709
文章通过介绍创建型设计模式的定义、背景和核心概念，帮助读者理解它们在软件开发中的重要性。创建型设计模式主要关注对象的创建过程，包括如何灵活地创建对象、管理对象的生命周期和实现对象的复用。文章通过具体的示例和代码片段，演示了如何使用这些设计模式来解决实际的软件设计问题。
C++各类设计模式及实现详解
热门推荐
Seven
08-19 4万+
总结了网上一些设计模式资料。     软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。最近看设计模式的书，对于每个模式，用C++写了个小例子，加深一下理解。主要参考《大话设计模式》和《设计模式:可复用面向对象软件的基础》两本书。
C++设计模式-创建型设计模式：简单工厂
最不正经的计算机专业学生
08-01 191
C++设计模式-简单工厂
2024年，Rust开发语言，现在怎么样了?
LiangGang365的专栏
10-27 1256
Rust到底好不好用，最终还是要看具体的业务场景应用。比如，目前用Rust来编写纯UI的前端，可能还不是很成熟。但在内存管理、安全性和性能优化等领域，Rust无疑是一种非常优秀的语言选择。国内华为、字节、百度、阿里、美团等在通用组件、基础平台系统都在使用rust，其他国内数据库厂商、交易所、理想汽车、小鹏汽车等，以及大量在区块链、游戏行业提供的远程职位
状态模式：封装对象状态并改变行为的设计模式
最新发布
wrxfxdd的博客
10-31 427
状态模式：封装对象状态并改变行为的设计模式
C++设计模式：创建型模式详解与实例
设计模式（3）主要探讨的是C++中的创建型模式，这些模式在软件设计中起着至关重要的作用。它们通过抽象实例化过程，使得系统能够独立于具体的类创建、组合和表示对象，从而提高系统的灵活性和可扩展性。这类模式分为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值