C++设计模式（二）创建型

最新推荐文章于 2023-11-20 14:09:13 发布
最新推荐文章于 2023-11-20 14:09:13 发布
阅读量237 收藏
点赞数
分类专栏： C++ 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44309282/article/details/106990040
版权

设计模式（二）

创建型模型

简单工厂模式：

简单工厂模式并不属于GoF的23种设计模式。

存在问题，
1.整个类的代码相当冗长，代码越长，阅读难度、维护难度和测试难度也越大。
2.违反了“单一职责原则”，
3.违反了“开闭原则”

优点：
(1)实现了对象创建和使用的分离。
(2)不需要记住具体类名，记住参数即可，减少使用者记忆量。

缺点：
(1)对工厂类职责过重，一旦不能工作，系统受到影响。
(2)增加系统中类的个数，复杂度和理解度增加。
(3)违反“开闭原则”，添加新产品需要修改工厂逻辑，工厂越来越复杂

使用场景：

  1. 工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。
  2. 客户端只知道传入工厂类的参数，对于如何创建对象并不关心。
    在这里插入图片描述
#define _CRT_SECURE_NO_WARNINGS
#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 FruitFactory{
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 test01(){
	
	//创建过程需要关心吗？ 直接拿来用
	
	//FruitFactory* factory = new FruitFactory;
	AbstractFruit* fruit = FruitFactory::CreateFruit("apple");
	fruit->ShowName();
	delete fruit;

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

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

	//delete factory;

}

int main(void){
	test01();
	return 0;
}

工厂方法模式

简单工厂模式 + “开闭原则” = 工厂方法模式

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

缺点：
(1)增加系统中类的个数，复杂度和理解度增加。导致类特别多
(2)增加了系统的抽象性和理解难度。

使用场景：

  1. 客户端不知道它所需要的对象的类。
  2. 抽象工厂类通过其子类来指定创建哪个对象。
  3. 在这里插入图片描述
#define _CRT_SECURE_NO_WARNINGS
#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 test01(){
	
	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;

}

int main(void){

	test01();
	return 0;
}

抽象工厂模式

优点：
(1)拥有工厂方法模式的优点
(2)当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。
(3)增加新的产品族很方便，无须修改已有系统，符合“开闭原则”。

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

适用场景：
(1) 系统中有多于一个的产品族。而每次只使用其中某一产品族。可以通过配置文件等方式来使得用户可以动态改变产品族，也可以很方便地增加新的产品族。
(2) 产品等级结构稳定。设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。
在这里插入图片描述

在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#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 AbsrtactBanana{
public:
	virtual void ShowName() = 0;
};

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

//美国香蕉
class USABanana : public AbsrtactBanana{
public:
	virtual void ShowName(){
		cout << "美国香蕉!" << endl;
	}
};

//日本香蕉
class JapanBanana : public AbsrtactBanana{
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 AbstracFactory{
public:
	virtual AbstractApple* CreateApple() = 0;
	virtual AbsrtactBanana* CreateBanana() = 0;
	virtual AbstractPear* CreatePear() = 0;
};

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


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

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

void test01(){
		
	AbstracFactory* factory = NULL;
	AbstractApple* apple = NULL;
	AbsrtactBanana* banana = NULL;
	AbstractPear* pear = NULL;

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

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

	delete pear;
	delete banana;
	delete apple;
	delete factory;
}

int main(void){
	test01();
	return 0;
}

单例模式（重要）

保证一个类仅有一个实例，并提供一个访问它的全局访问点

如何构建单例:
一是单例模式的类只提供私有的构造函数，
二是类定义中含有一个该类的静态私有对象， private
三是该类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象。static

分为1.懒汉式、2.饿汉式

单例对象，不需要手动去释放内存空间，因为只有单份，不可以new增加，不会造成内存溢出，系统结束时，会自动调用析构函数释放掉。

单例碰到多线程
1.懒汉式 是不安全的，因为程序运行时，可能同时进入判断，然后都new，就不符合单例了
2.饿汉式 是线程安全的，在线程启动之前，main之前，就已经new好一个了，不用判断，不会再new了

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

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

//懒汉式 
class Singleton_lazy{
private:
	Singleton_lazy(){}
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;


//饿汉式
class Singleton_hungry{
private:
	Singleton_hungry(){}
public:
	static Singleton_hungry* getInstance(){
		return pSingleton;
	}
private:
	static Singleton_hungry* pSingleton;	//静态成员变量类内声明
}; 
//类外初始化
Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry;

懒汉式，遇到多线程容易发生内存泄漏，我们可以可以用c++中的线程互斥量mutex来进行加强

class Singleton_Lazy
{
private:
	Singleton_Lazy(){}
	static Singleton_Lazy* qSingleton;
public:
	static pthread_mutex_t mutex;
	static Singleton_Lazy* getInstance();
};

pthread_mutex_t Singleton_Lazy::mutex;
Singleton_Lazy* Singleton_Lazy getInstance(){
		if (qSingleton == NULL )
		{
			pthread_mutex_lock(&mutex);//关闭锁
			if (qSingleton == NULL)
			{
				qSingleton  = new Singleton_Lazy;
			}
			pthread_mutex_unlock(&mutex);//打开锁
		}
		return qSingleton ;
	}

优点:
(1)单例模式提供了对唯一实例的受控访问。
(2)节约系统资源。由于在系统内存中只存在一个对象。

缺点:
(1) 扩展略难。单例模式中没有抽象层。
(2) 单例类的职责过重

适用场景
(1) 系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。
(2) 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。

单例模式——打印机案例

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;

class Printer{
private:
	Printer(){
		mCnt = 0;
	}
public:
	static Printer* getInstance(){
		return pPrinter;
	}

	//提供打印接口
	void print(string content){
		cout << "打印内容为:" << content << endl;
		mCnt++;
	}
	int getCnt(){
		return this->mCnt;
	}
private:
	static Printer* pPrinter;
	int mCnt; //统计打印次数
};

Printer* Printer::pPrinter = new Printer;

void test01(){
	
	Printer* printer = Printer::getInstance();
	printer->print("hello world1!");
	printer->print("hello world2!");
	printer->print("hello world3!");

	cout << "打印机打印次数:" << printer->getCnt() << endl;

}

int main(void){
	test01();
	return 0;
}
L&Li
关注
专栏目录
《C++ 设计模式》
青春不老，奋斗不止！
02-09 9万+
设计模式代表了最佳的实践，在面向对象的编程中被很多老鸟们反复使用。使用设计模式有很多好处：可重用代码、保证代码可靠性、使代码更易被他人理解 ......
设计模式--建造者模式（C++实现）
zhang_zhilai的博客
09-12 410
创建型设计模式共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 建造者模式：适用于复杂对象的构建，可以将其一步一步的构造出来，能够更精细的控制构建过程（每一步都可以控制）。 //建造者模式示例代码 #include<iostream> using namespace std; class Builder { public: virtual void buildHead() {}; virtual void buildBody() {}; virtual voi
设计模式(C++)创建型简介
qq_17347313的博客
03-27 249
最近在菜鸟教程了解了一些设计模式，记录一下 菜鸟地址：https://www.runoob.com/design-pattern/prototype-pattern.html 单例模式 单例模式（Singleton Pattern）。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供...
3.C++设计模式-创建型模型
weixin_42636062的博客
08-26 3230
3.C++设计模式-工厂模式 3.1 简单工厂模式 3.1.1 理论 3.1.2 简单工厂模式案例 不难看出，Fruit类是一个“巨大的”类，在该类的设计中存在如下几个问题： (1) 在Fruit类中包含很多“if…else…”代码块，整个类的代码相当冗长，代码越长，阅读难度、维护难度和测试难度也越大；而且大量条件语句的存在还将影响系统的性能，程序在执行过程中需要做大量的条件判断。 (2) Fruit类的职责过重，它负责初始化和显示所有的水果对象，将各种水果对象的初始化代码和显示代码集中在一个类中实现
c++设计模式详解_创建型设计模式
weixin_46935110的博客
07-17 2730
c++设计模式详解_创建型设计模式
设计模式以及C++实现(一)创建型模式
hhwhg123的博客
08-23 321
目录 入门之简单工厂 功能： 类图： C++代码简单实现： 工厂方法 功能： 类图： 代码： 抽象工厂 功能： 类图： 代码： 单例模式 功能： 类图： 代码： 原型模式 功能： 类图： 代码： 建造者模式 功能： 类图 代码： 入门之简单工厂 功能： 定义创建对象的接口，封装了对象的创建 类图： C++代码简单实现： #in...
c++设计模式-创建型模式-建造者模式
06-04
**建造者模式（Builder Pattern）**是软件设计模式中的一种创建型模式，它允许我们分步骤构建复杂的对象，而无需暴露构建过程。在C++中，这种模式常用于将对象的创建过程与使用过程分离，使得对象的构建更加灵活，...
23种设计模式(C++).pdf
11-29
《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》是一本深入探讨软件设计模式的书籍，它涵盖了创建型、结构型和行为型三种主要类型的23个经典设计模式，并提供了C++语言的实现代码。设计模式是软件工程中的...
C++设计模式之享元模式（Flyweight）
08-27
C++设计模式之享元模式（Flyweight）是一种结构型设计模式，主要用于解决大量相似对象的创建和操作所带来的内存负载问题。该模式的主要设计目标是通过共享对象来减少内存负载，提高系统的性能。 享元模式顾名思义...
c++设计模式全系列+应用场景+实例说明
最新发布
04-01
1. **工厂模式（Factory Pattern）**：工厂模式是一种创建型设计模式，用于创建对象而无需指定创建对象的具体类。包括简单工厂模式、工厂方法模式和抽象工厂模式。 2. **单例模式（Singleton Pattern）**：单例模式...
C++设计模式（一）——创建型模式
lincccbb的博客
07-03 255
设计模式指导我们怎样去创建、维护、分配面向对象系统中的实体类，以获得高内聚、低耦合的面向对象系统，从而提高系统的可维护性和可复用性。设计模式是OO的一些设计思想的一个总结（但不是全部），因此设计模式和OO的设计原则经验没有矛盾，而是殊途同归。 一、创建型模式 1、Factory模式         Factory模式的两个最重要的功能：       1）定义创建对象的接
c++创建型设计模式--工厂模式--抽象工厂（多个产品的构建--系列）
riversky的博客
10-12 377
在基类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++设计模式》——创建型
小小博客
09-07 537
前言 Factory Method(工厂模式) Abstract Factory(抽象工厂) Builder(建造者) Prototype(原型) Singleton(单例) 后记
C++创建模式
test
05-09 316
常用的创建设计模式包括如下4种：1 生成器模式2 工厂模式3 原型模式4 单例模式在软件工程中，创建模式是用来处理目标创建的机制，尝试以合适的方式创建对象的解决方法。对象创建的的基本形式可能会导致设计问题或者增加设计的复杂性。创建模式通过对象的创建解决这个问题。生成器模式：生成器模式从复杂对象的表现形式中分离出它的构造函数，可以实现相同的构造函数创建出不通的对象。问题：我们想构建复杂的对象，但是我...
创建型设计模式- C++实现
阿呆的隐秘角落
08-03 233
设计模式-创建类设计模式 - C++实现
[C/C++后端开发学习] 5 设计模式：创建型
jiang_T的博客
10-22 1277
设计模式：创建型设计模式定义如何学习设计模式？设计原则依赖倒置开放封闭面向接口封装变化点单一职责理氏替换接口隔离组合优于继承原则的层次关系模板方法本质观察者模式补充：互斥锁和自旋锁策略模式 设计模式定义 设计模式是指在软件开发中，经过验证的，用于解决在特定环境下，重复出现的，特定问题的解决方案 如何学习设计模式？ 找到稳定点和变化点，把变化点隔离出来（解耦合-把耦合限定在最小范围） 先满足设计原则，慢慢迭代出设计模式（分治思维） 设计原则 依赖倒置 高层模块不应该依赖低层模块，两者都应该依赖抽象
C++设计模式之创建型模式
maobin_1的博客
11-20 158
1、单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供一个访问它的全局访问点。例如，在一个多线程程序中，使用单例模式可以确保只有一个线程访问某个资源。C++设计模式的创建型模式可以分为单例模型、简单工厂模式、工厂方法模式、抽象工厂模式、原型模式、建造者模式。
C++设计模式系列之一创建型模式
F_r_e_e_x的专栏
06-21 1017
1.简单工厂模式 Factory.hpp: #ifndef _FACTORY_HPP_ #define _FACTORY_HPP_ #include class Product {     public:         virtual ~Product(){}     protected:         Product(){} }; class XXProduc
c++创建型设计模式--工厂模式--简单工厂（单个产品的构建）
riversky的博客
10-12 312
思想 主要是对于单个简单的产品进行构建 基类 #pragma once #include &amp;lt;iostream&amp;gt; /** * 基类指针 *Date :[10/12/2018 ] *Author :[RS] */ class CarBase { public: virtual ~CarBase() { std::cout &amp;lt;&amp;lt; &quot;析构 carBase&quot; &amp;
C++设计模式：创建型模式详解与实例
设计模式（3）主要探讨的是C++中的创建型模式，这些模式在软件设计中起着至关重要的作用。它们通过抽象实例化过程，使得系统能够独立于具体的类创建、组合和表示对象，从而提高系统的灵活性和可扩展性。这类模式分为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值