常见的创建型设计模式( 一 )

设计模式( 一 )

常见的创建型设计模式

1.单例模式 : 确保一个类只有一个实例 , 为整个程序提供一个全局的访问接口。getInstance

实现方式

  • 饿汉式，在调用getInstance 创建实例的时候 ，实例已经存在了 ，不需要我们再次去 new创建。
    优点： 实现简单 ， 在多线程的环境下是线程安全的。
class Singleton {
  public:
  	static Singleton* getInstance() {
  		return singleton.get();   // 返回管理的原始指针
  	}
  	~Singleton() { cout << __FUNCTION__ << endl;  }
  private:
  	Singleton() { cout << __FUNCTION__ << endl; }
  	
  
  	Singleton(const Singleton& other) = delete;
  	Singleton& operator =(const Singleton& other) = delete;
  
  	static unique_ptr< Singleton >singleton;  // 用智能指针来托管这个有生命周期的对象.避免我们手动去释放
  };
  
  unique_ptr< Singleton>Singleton::singleton( new Singleton);
  • 懒汉式，第一次使用的时候, 才初始化实例
    缺点: 不适合多线程环境( 如果要在多线程下使用 ,需要加锁 )
    优点: 节省资源
  // 利用C++11的新特性 线程安全且简单
  #include <mutex>
  
  class Singleton {
  public:
  	static Singleton* getInstance() {
  		call_once(flag, []() {   // 保存对象只 new 一次
  			singleton.reset(new Singleton);
  			});
  		return singleton.get(); // 返回管理的原始指针
  	}
  	
  	~Singleton() { cout << __FUNCTION__ << endl; }
  private:
  	Singleton() { cout << __FUNCTION__ << endl; }
  	
  	Singleton(const Singleton& other) = delete;
  	Singleton& operator =(const Singleton& other) = delete;
  
  	static unique_ptr<Singleton>singleton;
  	static once_flag flag;
  };
  
  unique_ptr< Singleton>Singleton::singleton;
  once_flag Singleton::flag;
  
  
  // 其他的写法 ,可以参考
  class Singleton {
  public:
  	static Singleton* getInstance() {
  		statict Singleton singleton;
          return &singleton;
  	}
  private:
  	Singleton() { cout << __FUNCTION__ << endl; }
      ~Singleton() { cout << __FUNCTION__ << endl; }
  	
  	Singleton(const Singleton& other) = delete;
  	Singleton& operator =(const Singleton& other) = delete;
  };

适用场景 : 线程池 、系统日志、内存池。等等

2.简单工厂模式: 定义一个工厂类 , 用来创建不同类型的对象实例 .
目的: 将对象创建的过程封装在工厂类里面 , 我们只需要调用工厂类的生产方法 ,而不需要关心具体的实现过程.
基本结构

  • 工厂类 —>用于创建对象的实例
  • 产品类 —> 创建对象的父类
  • 具体产品类----> 继承产品类 , 重写父类的virtual 方法.

具体实现方法:

// 产品类
class Animal {
public:
	Animal() { }; 
	virtual void eat() = 0;
	virtual void drinking() = 0;

	virtual ~Animal( ) { }
};

// 具体产品类
class Dog :public Animal {
public:
	Dog() { }
	virtual ~Dog() { }

	virtual void eat() { std::cout << "++ Dog eat" << std::endl; }
	virtual void drinking() { std::cout << "++ Dog drinking" << std::endl; }
};

// 具体产品类
class Cat :public Animal {
public:
	Cat() { }
	virtual ~Cat() { }

	virtual void eat() { std::cout << "++ Cat eat" << std::endl; }
	virtual void drinking() { std::cout << "++ Cat drinking" << std::endl; }
};

// 具体产品类
class Beef :public Animal {
public:
	Beef() { }
	virtual ~Beef() { }

	virtual void eat() { std::cout << "++ Beef eat" << std::endl;  }
	virtual void drinking() { std::cout << "++ Beef drinking" << std::endl;  }
};

// 产品类型
enum class AnimalType :char
{
	Dog,
	Cat,
	Beef
};

// 工厂类
class Factory {
public:
	Factory() { };
	~Factory() { };
	// 生产
	Animal* make_animal( AnimalType  type ) {
		Animal* animal = nullptr;
		switch ( type )
		{
		case AnimalType::Cat:
			animal = new Cat;
			break;
		case AnimalType::Dog:
			animal = new Dog;
			break;
		case AnimalType::Beef:
			animal = new Beef;
			break;
		default:
			break;
		}
		return animal;
	}
};


int main( ) {
	
    // 创建一个工厂实例 , 调用生产方法 ,生成我们需要的产品.
	Factory factory;   

	Animal* Beef = factory.make_animal(AnimalType::Beef);
	Beef->drinking();

	Animal* Dog = factory.make_animal(AnimalType::Dog);

	Dog->eat();

	system("pause");

	return 0;
}

适用场景： 创建对象的逻辑较为简单、对象类型较少。

3.工厂模式: 它定义了一个创建对象的工厂，但由工厂的子类决定生成哪一个产品。
基本结构：

  • 工厂类 —>定义生产产品的接口
  • 具体工厂类—>继承工厂类 ， 对生产接口进行具体实现。返回具体的产品实例
  • 产品类—>定义产品的父类
  • 具体产品类 —> 继承产品类 ，实现产品类的具体方法。

具体的实现：

// 产品类
class Animal {
public:
	Animal() { }; 
	virtual void eat() = 0;
	virtual void drinking() = 0;

	virtual ~Animal( ) { }
};

// 具体产品类
class Dog :public Animal {
public:
	Dog() { }
	virtual ~Dog() { }

	virtual void eat() { std::cout << "++ Dog eat" << std::endl; }
	virtual void drinking() { std::cout << "++ Dog drinking" << std::endl; }
};

// 具体产品类
class Cat :public Animal {
public:
	Cat() { }
	virtual ~Cat() { }

	virtual void eat() { std::cout << "++ Cat eat" << std::endl; }
	virtual void drinking() { std::cout << "++ Cat drinking" << std::endl; }
};

// 具体产品类
class Beef :public Animal {
public:
	Beef() { }
	virtual ~Beef() { }

	virtual void eat() { std::cout << "++ Beef eat" << std::endl;  }
	virtual void drinking() { std::cout << "++ Beef drinking" << std::endl;  }
};

// 工厂类
class AbstractFactory {
public:
	AbstractFactory() { };
	virtual ~AbstractFactory() { };
	// 生产
	virtual Animal* make_animal( ) = 0;
};

// 具体工厂类
class DogFactory : public AbstractFactory {
public:
	DogFactory() { }
	virtual ~DogFactory() { }

	virtual Animal* make_animal() {
		return new Dog;
	}
};

// 具体工厂类
class CatFactory : public AbstractFactory {
public:
	CatFactory() { }
	virtual ~CatFactory() { }

	virtual Animal* make_animal() {
		return new Cat;
	}
};

// 具体工厂类
class BeefFactory : public AbstractFactory {
public:
	BeefFactory() { }
	virtual ~BeefFactory() { }

	virtual Animal* make_animal() {
		return new Beef;
	}
};

int main( ) {
	
	// 创建一个狗的工厂 ，用于生产狗
	AbstractFactory  *factory_dog = new DogFactory;
	Animal* dog = factory_dog->make_animal();

	dog->eat();

	// 创建一个猫的工厂 ，用于生产猫
	AbstractFactory* factory_cat = new CatFactory;
	Animal* cat = factory_cat->make_animal();

	cat->drinking();

	system("pause");

	return 0;
}

工厂模式是对简单工厂模式的优化 ， 将生产产品的的过程延申到工厂的子类中进行实现 ， 提高程序的可扩展性。

4.抽象工厂模式: 提供一系列创建产品的接口 , 无需指定具体的类.

适用于: 生产的产品结构比较复杂的类, 入电脑 , 汽车( 由很多零部件构成 , 而同一个零部件又有很多类型).

基本结构:

  • 抽象工厂—> 定义创建产品的方法.
  • 具体工厂—> 实现创建产品的方法 , 这些方法会返回一个具体的产品.
  • 抽象产品 —> 为每种产品声明一个接口.
  • 具体产品 —> 实现抽象产品的接口.
  • 客户端 —> 通过抽象工厂和抽象产品来生产产品.

例如: 建造一海贼艘船

|---------------------- --基础版-----------------豪华版----------------旗舰版 |
| 动力系统------------船桨--------------------内燃机----------------核动力 |
| 防御系统------------防空机枪--------------反舰导弹-------------激光炮 |
| 创建材料------------木头--------------------钢铁-------------------合金 |

具体实现:

#include <iostream>
#include <string>

// 动力系统抽象类
class AbstractPower {
public:
	AbstractPower() {  }
	virtual ~AbstractPower( ) { }

	virtual std::string getPower() = 0;
};

// 船桨动力
class BodyPower : public AbstractPower {
public:
	BodyPower() { }
	virtual ~BodyPower() { }

	virtual std::string getPower() {
		return std::string("< 船桨>动力系统");
	}
};

// 内燃机
class EnginePower : public AbstractPower {
public:
	EnginePower() { }
	virtual ~EnginePower() { }

	virtual std::string getPower() {
		return std::string("< 内燃机>动力系统");
	}
};

// 核动力
class EnergyPower : public AbstractPower {
public:
	EnergyPower() { }
	virtual ~EnergyPower() { }

	virtual std::string getPower() {
		return std::string("< 核能>动力系统");
	}
};

// 防御系统抽象类
class AbstractDefense {
public:
	AbstractDefense() { }
	virtual ~AbstractDefense() { }

	virtual std::string getDefense() = 0;
};

// 防空机枪
class Gun : public AbstractDefense {
public:
	Gun() { }
	virtual ~Gun() { }

	virtual std::string getDefense() {
		return std::string("<防空机枪>防御系统");
	}
};

// 反舰导弹
class Guided : public AbstractDefense {
public:
	Guided() { }
	virtual ~Guided() { }

	virtual std::string getDefense() {
		return std::string("<防空导弹>防御系统");
	}
};

// 激光炮
class Laser : public AbstractDefense {
public:
	Laser() { }
	virtual ~Laser() { }

	virtual std::string getDefense() {
		return std::string("<激光炮>防御系统");
	}
};

// 建造材料抽象类
class AbstractMaterials {
public:
	AbstractMaterials() { }
	virtual ~AbstractMaterials() { }

	virtual std::string getMaterials() = 0;
};

// 木头
class Wood :public AbstractMaterials {
public:
	Wood() { }
	virtual ~Wood() { }

	virtual std::string getMaterials() {
		return std::string("<木头>建造");
	}
};

// 钢铁
class Steel :public AbstractMaterials {
public:
	Steel() { }
	virtual ~Steel() { }

	virtual std::string getMaterials() {
		return std::string("<钢铁>建造");
	}
};

// 合金
class Alloy :public AbstractMaterials {
public:
	Alloy() { }
	virtual ~Alloy() { }

	virtual std::string getMaterials() {
		return std::string("<合金>建造");
	}
};

// 船
class Shop {
public:
	Shop(AbstractPower* power, AbstractDefense* defence, AbstractMaterials* materials):power_(power), defence_(defence), materials_( materials ){  }

	~Shop( ) { 
		delete power_;
		delete defence_;
		delete materials_;
	}
	std::string getShopInforamtion() {
		std::string info = power_->getPower() + defence_->getDefense() + materials_->getMaterials();
		return info;
	}
private:
	AbstractPower* power_;         // 动力系统
	AbstractDefense* defence_;     // 防御系统
	AbstractMaterials* materials_;  // 建造材料
};


// 工厂抽象类
class AbstractFactory {
public:
	AbstractFactory( ) { }
	virtual ~AbstractFactory() { }

	virtual Shop* CreateShop() = 0;
};

class BasicShop :public AbstractFactory {
public:
	BasicShop( ) { }
	virtual ~BasicShop( ){ }

	virtual Shop* CreateShop() {
		Shop* shop = new Shop(new BodyPower, new Gun, new Wood);
		std::cout << "<基础形>海贼船建造完毕" << std::endl;
		return shop;
	}
};

// 
class LuxuryShop :public AbstractFactory {
public:
	LuxuryShop() { }
	virtual ~LuxuryShop() { }

	virtual Shop* CreateShop() {
		Shop* shop = new Shop(new EnginePower, new Guided, new Steel);
		std::cout << "<豪华型>海贼船建造完毕" << std::endl;
		return shop;
	}
};

class FlagshipShop :public AbstractFactory {
public:
	FlagshipShop() { }
	virtual ~FlagshipShop() { }

	virtual Shop* CreateShop() {
		Shop* shop = new Shop( new EnergyPower , new Laser, new Alloy);
		std::cout << "<旗舰型>海贼船建造完毕" << std::endl;
		return shop;
	}
};

int main() {
	
	AbstractFactory* factory = new BasicShop;
	Shop *shop = factory->CreateShop();
	std::cout << shop->getShopInforamtion() << std::endl;

	return 0;
}

效果演示:

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/725279.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

css布局之flex应用

css布局之flex应用

/*父 100*/.parent-div {/* 这里添加你想要的属性 */display: flex;flex-direction: row; //行justify-content: space-between; //左右对齐align-items: center;flex-wrap: wrap; //换行}/*中 90 10 */.middle-div {/* 这里添加你想要的属性 */display: flex;flex-direction:…
阅读更多...
jenkins安装和使用 (二)

jenkins安装和使用 (二)

参考视频资料 https://www.bilibili.com/video/BV1bS4y1471A?p10&vd_sourcee0dcd147bd5d730317de804d788cd6f9 安装maven插件 新建item 配置构建信息 项目地址替换为自己的实际地址 其余保持先保持默认 先然后在主页就看到了这个项目 查看控制台输出 稍等一…
阅读更多...
小林图解系统-二.硬件结构 2.5CPU是如何执行任务的？

小林图解系统-二.硬件结构 2.5CPU是如何执行任务的？

CPU如何读取数据的&#xff1f; CPU访问L1 Cache速度比访问内存快100倍&#xff0c;有高速缓存的目的&#xff1a;把Cache作为CPU与内存之间的缓存层&#xff0c;减少对内存的访问频率 所有CPU Cache Line是CPU从内存读取数据到Cache的单位。 64字节 CPU加载数组里面连续的多…
阅读更多...
Kubernetes入门-Kubernetes集群构成

Kubernetes入门-Kubernetes集群构成

目录 前言 控制面板节点与工作节点 控制面板节点 工作节点 被托管的Kubernetes 用kubectl命令行工具管理Kubernetes 前言 前面说过&#xff0c;Kubernetes是云的操作系统顾名思义&#xff0c;它位于应用和基础设施之间Kubernetes运行在基础设施上&#xff0c;而应用运行…
阅读更多...
【Linux安装Conda环境的详细教程】

【Linux安装Conda环境的详细教程】

&#x1f308;个人主页: 程序员不想敲代码啊 &#x1f3c6;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家 &#x1f44d;点赞⭐评论⭐收藏 &#x1f91d;希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出指正&#xff0c;让我们共…
阅读更多...
服务器流量收发测试

服务器流量收发测试

文章目录 一、概述二、实现方式一&#xff1a;编码1. 主要流程2. 核心代码3. 布署 三、实现方式二&#xff1a;脚本1.脚本编写2. 新增crontab任务 四、查看结果 一、概述 我们在安装vnStat、wondershaper便想通过实际的数据收发来进行测试。 二、实现方式一&#xff1a;编码 …
阅读更多...
外包干了2年，彻底废了...

外包干了2年，彻底废了...

先说一下自己的情况。大专生&#xff0c;17年通过校招进入湖南某软件公司&#xff0c;干了接近2年的点点点&#xff0c;今年年上旬&#xff0c;感觉自己不能够在这样下去了&#xff0c;长时间呆在一个舒适的环境会让一个人堕落&#xff01;而我已经在一个企业干了五年的功能测试…
阅读更多...
UniAudio 1.5：大型语言模型（LLMs）驱动的音频编解码器

UniAudio 1.5：大型语言模型（LLMs）驱动的音频编解码器

大型语言模型&#xff08;LLMs&#xff09;在文本理解和生成方面展示了卓越的能力&#xff0c;但它们不能直接应用于跨模态任务&#xff0c;除非进行微调。本文提出了一种跨模态上下文学习方法&#xff0c;使未进行进一步训练的LLMs能够在少量示例的情况下&#xff0c;无需任何…
阅读更多...
面向机电工程和制造项目数字管理-项目一体化解决方案

面向机电工程和制造项目数字管理-项目一体化解决方案

一、专业面向机电工程和制造项目管理 1、项目范围管理 大多数企业有这样的经历&#xff0c;项目做了很久感觉做不完&#xff0c;就像是个无底洞。项目中哪些该做&#xff0c;哪些不该做&#xff0c;做到什么程度没有一个实际的把控。这里就会涉及到“范围管理”的概念。 2、…
阅读更多...
[机器学习算法]决策树

[机器学习算法]决策树

1. 理解决策树的基本概念 决策树是一种监督学习算法&#xff0c;可以用于分类和回归任务。决策树通过一系列规则将数据划分为不同的类别或值。树的每个节点表示一个特征&#xff0c;节点之间的分支表示特征的可能取值&#xff0c;叶节点表示分类或回归结果。 2. 决策树的构建…
阅读更多...
【Qt 学习笔记】Qt窗口 | 标准对话框 | 颜色对话框QColorDialog

【Qt 学习笔记】Qt窗口 | 标准对话框 | 颜色对话框QColorDialog

博客主页&#xff1a;Duck Bro 博客主页系列专栏&#xff1a;Qt 专栏关注博主&#xff0c;后期持续更新系列文章如果有错误感谢请大家批评指出&#xff0c;及时修改感谢大家点赞&#x1f44d;收藏⭐评论✍ Qt窗口 | 标准对话框 | 颜色对话框QColorDialog 文章编号&#xff1a;…
阅读更多...
IFM易福门SV7500SV4200涡街流量计型号都是进口的。

IFM易福门SV7500SV4200涡街流量计型号都是进口的。

IFM易福门SV7500SV4200涡街流量计型号都是进口的。工程余料。
阅读更多...
【docker安装rabbitmq】

【docker安装rabbitmq】

docker安装rabbitmq 1.查阅rabbitmq的Dokcer Hub官方说明 rabbitmq地址&#xff0c;因为我们需要使用的是带管理界面的rabbitmq服务。所以我们需要下载的rabbitmq:management镜像 docker pull rabbitmq:management2.启动rabbitmq 2.1.快速启动 One of the important thing…
阅读更多...
新火种AI|实属罕见！四大AI顶流同台，有哪些关键信息值得关注？

新火种AI|实属罕见！四大AI顶流同台，有哪些关键信息值得关注？

作者&#xff1a;小岩 编辑&#xff1a;彩云 在有着“AI春晚”之称的2024年智源大会上&#xff0c;非常难得的一幕出现了&#xff1a;当下国内的四大AI顶流公司——月之暗面&#xff0c;百川智能&#xff0c;智谱AI&#xff0c;面壁智能齐聚一堂&#xff0c;十分罕见的同台了…
阅读更多...
PHP转Go系列 | 变量常量的使用姿势

PHP转Go系列 | 变量常量的使用姿势

大家好&#xff0c;我是码农先森。 变量 在 PHP 语言中&#xff0c;初始化变量虽然只有一行&#xff0c;其实包含了两步&#xff0c;一是声明变量&#xff0c;二是赋值给变量&#xff0c;同一个变量可以任意再赋值任何类型的数据。 <?php// 初始化变量 $name "man…
阅读更多...
白酒：酒文化的地域特色与差异

白酒：酒文化的地域特色与差异

中国的白酒文化&#xff0c;作为一种深深植根于人们生活中的文化现象&#xff0c;其发展历程深受地域特色的影响&#xff0c;从而形成了丰富多样的地域特色与差异。云仓酒庄的豪迈白酒&#xff0c;作为中国白酒的品牌&#xff0c;其背后所蕴含的地域特色与差异更是值得我们去探…
阅读更多...
【pytorch01】简单回归问题

【pytorch01】简单回归问题

1.梯度下降&#xff08;Gradient Descent&#xff09; y x 2 ∗ s i n ( x ) yx^{2}*sin(x) yx2∗sin(x) y ′ 2 ∗ x ∗ s i n ( x ) x 2 ∗ c o s ( x ) y2*x*sin(x) x^{2}*cos(x) y′2∗x∗sin(x)x2∗cos(x) 求最小值要求导 梯度下降定义&#xff1a;梯度下降要迭代计…
阅读更多...
Python接口测试实战之搭建自动化测试框架

Python接口测试实战之搭建自动化测试框架

&#x1f345; 视频学习&#xff1a;文末有免费的配套视频可观看 &#x1f345; 点击文末小卡片&#xff0c;免费获取软件测试全套资料&#xff0c;资料在手&#xff0c;涨薪更快 一.数据分离:从Excel中读取数据 之前的用例中&#xff0c;数据直接写在代码文件里&#xff0c;不…
阅读更多...
【UML用户指南】-19-对基本行为建模-用例图

【UML用户指南】-19-对基本行为建模-用例图

目录 1、组成结构 2、表示法 3、一般用法 3.1、对主题的语境建模 3.2、对主题的需求建模 4、常用建模技术 4.1、对系统的语境建模 4.1.1、设计过程 4.2、对系统的需求建模 4.2.1、设计过程&#xff1a; 5、正向工程 UML 中的用例图是对系统的动态方面建模的 5 种图之…
阅读更多...
202483读书笔记|《牵牛花浮世无篱笆：千代尼俳句250》——被红叶染红的只有一侧山坡之山 啊，单恋

202483读书笔记|《牵牛花浮世无篱笆：千代尼俳句250》——被红叶染红的只有一侧山坡之山 啊，单恋

202483读书笔记|《牵牛花浮世无篱笆&#xff1a;千代尼俳句250》——被红叶染红的只有一侧山坡之山 啊&#xff0c;单恋 春之句夏之句秋之句冬之句 历史读过的俳句列表: 202318读书笔记|《芭蕉芜村一茶&#xff1a;俳句三圣新译300》——樱花——让一整个春夜亮起来&#xff0…
阅读更多...
最新文章

Copyright @ 2022~2023