【工厂模式】

最新推荐文章于 2024-06-15 15:08:31 发布
最新推荐文章于 2024-06-15 15:08:31 发布
阅读量173 收藏
点赞数
分类专栏： 设计模式 文章标签： c++ 设计模式 抽象工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fang_guobing/article/details/131615005
版权

什么是工厂模式

工厂模式（Factory Pattern）是一种创建对象的设计模式，它提供了一种封装对象创建过程的方式，以便于客户端代码使用抽象接口来创建对象，而无需关心具体的对象实现类。
工厂模式的核心思想是将对象的创建逻辑封装在一个工厂类中，客户端通过与工厂类交互来创建所需的对象。也就是说， 工厂可以生产产品，而客户只需要调用工厂提供的接口得到想要的产品。
工厂模式设计有三种： 简单工厂模式， 工厂模式， 抽象工厂模式。

1. 简单工厂模式

首先， 简单工厂模式会提供一个产品的抽象类，然后根据这个产品抽象类派生出一系列的具体产品类。（抽象类就相当于还是概念产品， 派生类就是实际落地的产品，工厂给用户的产品就是派生类的实例对象。）

在shop.h中， 定义了一个抽象类，它代表了一个抽象产品，可以通过cost（）得到购买商品的花销，get（）可以得到商品的效果（恢复HP）。
随后，派生出具体的商品类（Littleshop、Middleshop、Bigshop），在派生类中通过函数重写实现了cost（）和get（）接口。

//shop.h
#pragma once//（c++11 特性）相当于ifndef def endif

#include <iostream>

class Abstractshop//抽象商品类
{
public:
    virtual void cost() {}
    virtual void get() {}
    virtual ~Abstractshop() {}
};

class Littleshop : public Abstractshop
{
public:
    void cost() override//（c++11 特性） 显式声明函数重写，禁止函数隐藏，这是为了实现多态
    {
        std::cout << "cost 10$" << std::endl;
    }
    void get() override
    {
        std::cout << "Hp + 10" << std::endl;
    }
};

class Middleshop : public Abstractshop
{
public:
    void cost() override
    {
        std::cout << "cost 15$" << std::endl;
    }
    void get() override
    {
        std::cout << "Hp + 20" << std::endl;
    }
};

class Bigshop : public Abstractshop
{
public:
    void cost() override
    {
        std::cout << "cost 50$" << std::endl;
    }
    void get() override
    {
        std::cout << "Hp + 100" << std::endl;
    }
};

在Factory.h中，定义了一个Factory类，代表工厂，通过creatshop（）函数生产产品。为了实现多态，creatshop（）函数返回Abstractshop*。
另外，还定义了一个类型为char的枚举类，用以选择不同型号的产品。

//Factory.h

#pragma once

#include "shop.h"

enum class Type : char { LITTLE, MIDDLE, BIG };

class Factory
{
public:
    Factory() {
		std::cout<<"工厂开工！！！."<<std::endl;
	}
    ~Factory() {
		std::cout<<"工厂停工！！！."<<std::endl;
	}

    Abstractshop* createshop(Type type)
    {
	Abstractshop* ptr = nullptr;
    	switch (type)
    	{
    	case Type::LITTLE:
    		std::cout<<"You buy a Little Shop." << std::endl;
        	ptr = new Littleshop;
        	break;
        
    	case Type::MIDDLE:
    		std::cout<<"You buy a Middle Shop." << std::endl;
        	ptr = new Middleshop;
        	break;
        
    	case Type::BIG:
    		std::cout<<"You buy a Big Shop." << std::endl;
        	ptr = new Bigshop;
        	break;
        
    	default:
        	break;
    	}
    	return ptr;
    }
};

  1 #include "Factory.h"
  2
  3 int main()
  4 {
  5         Factory* factory = new Factory;
  6         Abstractshop* obj = factory->createshop(Type::MIDDLE);
  7         obj->cost();
  8         obj->get();
  9
 10         delete obj;
 11         delete factory;
 12
 13         return 0;
 14 }

在这里插入图片描述

简单工厂模式有个很明显缺点就是：不满足类的三大原则之一——开放-封闭原则。

开发封闭原则：软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。

假如我们要增加新商品类，可以通过抽象商品类派生（扩展）。但是工厂类就不得不修改，以增加对新商品类的选择。这就违背了设计类的原则。

工厂模式

在工厂模式我们将设计一个抽象工厂类。然后派生出只能生产某一具体产品的工厂。这相当于是把简单工厂模式中的工厂类拆分成了多个子工厂。每个子工厂只生产一种产品。
在这样的情况下， 如果想增加一个新商品，那么只需要在shop.h中派生一个新的商品类。对应的，在Factor.h中也得新派生一个新商品的工厂类。这样就不会违背开发-封闭原则了。

//Factory.h

#pragma once

#include "shop.h"

class AbstractFactory
{
public:
    virtual ~AbsreactFactory() {}
    virtual Abstractshop* createshop(){}
};

class LittleShop : public AbstractShop()
{
public:
	LittleShop(){
		std::cout<< "LittleShop 开业!!!"<<std::endl;
	}
	Abstractshop* createshop() override
	{
		std::cout<<"You buy a Littleshop."<<std::endl;
		return new Littleshop;
	}
	~LitteShop(){
		std::cout<< "littleShop 开业!!!"<<std::endl;
	}
}

class MiddleShop : public AbstractShop()
{
public:
	MiddleShop(){
		std::cout<< "MiddleShop 开业!!!"<<std::endl;
	}
	Abstractshop* createshop() override
	{
		std::cout<<"You buy a Middleshop."<<std::endl;
		return new Middleshop;
	}
	~MiddleShop(){
		std::cout<< "MiddleShop 开业!!!"<<std::endl;
	}
}

class BigShop : public AbstractShop()
{
public:
	BigShop(){
		std::cout<< "BigShop 开业!!!"<<std::endl;
	}
	Abstractshop* createshop() override
	{
		std::cout<<"You buy a Bigshop."<<std::endl;
		return new Bigshop;
	}
	~BigShop(){
		std::cout<< "BigShop 开业!!!"<<std::endl;
	}
}

抽象工厂模式

抽象工厂模式可以理解为工厂模式的升级。工厂模式下，一个工厂只能产出一种商品。而抽象模式下，一个工厂可以产生商品的组合,或者说是可以生产多种商品。（工厂模式就是生产单品，抽象工厂模式是把不同商品组合，产出一个套餐）

//shop.h
#pragma once//（c++11 特性）相当于ifndef def endif

#include <iostream>

class Abstractshop
{
public:
    virtual void cost(){}
    virtual void get(){}
    virtual ~Abstractshop(){}
};

class Littleshop : public Abstractshop
{
public:
    Littleshop(){
    	std::cout<<"You get a littleshop, ";
    	this->cost();
    }
    ~Littleshop(){
    	std::cout<<"You used a littleshop, ";
    	this->get();
    }
    void cost() override//（c++11 特性） 显式声明函数重写，禁止函数隐藏，这是为了实现多态
    {
        std::cout << "cost 10$" << std::endl;
    }
    void get() override
    {
        std::cout << "Hp + 10" << std::endl;
    }
};

class Middleshop : public Abstractshop
{
public:
    Middleshop(){
    	std::cout<<"You get a Midlleshop, ";
    	this->cost();
    }
    ~Middleshop(){
    	std::cout<<"You used a Middleshop, ";
    	this->get();
    }
    void cost() override
    {
        std::cout << "cost 15$" << std::endl;
    }
    void get() override
    {
        std::cout << "Hp + 20" << std::endl;
    }
};

class Bigshop : public Abstractshop
{
public:
    Bigshop(){
    	std::cout<<"You get a Bigshop, ";
    	this->cost();
    }
    ~Bigshop(){
    	std::cout<<"You used a Bigshop, ";
    	this->get();
    }
    void cost() override
    {
        std::cout << "cost 50$" << std::endl;
    }
    void get() override
    {
        std::cout << "Hp + 100" << std::endl;
    }
};

//AbstractFactory.h

#pragma once

#include "shop.h"
#include "memory"

class Package//套餐类
{
private: 
	std::unique_ptr<Abstractshop> shop1_=NULL;
	std::unique_ptr<Abstractshop> shop2_=NULL;
	
public:	
	Package(Abstractshop* shop1, Abstractshop* shop2):shop1_(shop1), shop2_(shop2){
		std::cout<<"Your package is complete!"<<std::endl;
	}
	~Package(){
		std::cout<<"Your Package is used!" <<std::endl;
	}
};

class AbstractFactory//抽象工厂类
{
public:
	
    virtual ~AbstractFactory() {}
    virtual Package* createPackage()=0;//生产套餐
};

class ToLPackage : public AbstractFactory//经济套餐工厂
{
public:
	Package* createPackage() override{
		std::cout<< "你购买了经济套餐!!!"<<std::endl;
		return new Package(new Littleshop, new Littleshop);
	}
	ToLPackage()
	{
		std::cout<< "经济套餐工厂开工!!!"<<std::endl;
	}
	~ToLPackage(){
		std::cout<< "经济套餐工厂停工!!!"<<std::endl;
	}
};

class ToMPackage : public AbstractFactory//小资套餐工厂
{
public:
	Package* createPackage() override{
		std::cout<< "你购买了小资套餐!!!"<<std::endl;
		return new Package(new Middleshop, new Middleshop);
	}
	ToMPackage()
	{
		std::cout<< "小资套餐工厂开工!!!"<<std::endl;
	}
	~ToMPackage(){
		std::cout<< "小资套餐工厂停工!!!"<<std::endl;
	}
};

class ToBPackage : public AbstractFactory//富翁套餐工厂
{
public:
	Package* createPackage() override{
		std::cout<< "你购买了富翁套餐!!!"<<std::endl;
		return new Package(new Bigshop, new Bigshop);
	}
	ToBPackage()
	{
		std::cout<< "富翁套餐工厂开工!!!"<<std::endl;
	}
	~ToBPackage(){
		std::cout<< "富翁套餐工厂停工!!!"<<std::endl;
	}
};

在主函数中，先创建了3个工厂。然后让L_factory生产了一个套餐产品pkg。

//main.cpp
#include "AbstractFactory.h"
#include <memory>

int main()
{
    	std::unique_ptr<AbstractFactory> L_factory (new ToLPackage());
    	std::unique_ptr<AbstractFactory> M_factory ( new ToMPackage() );
    	std::unique_ptr<AbstractFactory> B_factory ( new ToBPackage() );
    	
		std::unique_ptr<Package> pkg (L_factory->createPackage());
	
    	return 0;
}

在这里插入图片描述

fang_guobing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简单工厂模式
03-06
java设计模式 简单工厂模式详解 simple factory static pattern
js简单工厂模式用法实例
10-24
主要介绍了js简单工厂模式用法,实例分析了javascript工厂模式的实现原理,需要的朋友可以参考下
C#工厂模式
03-24
包含C#实现的简单工厂、工厂方法、抽象工厂例子，学习工厂模式用
设计模式之工厂模式总结
12-21
设计模式之工厂模式 什么是工厂模式？ 工厂模式是一种常见的设计模式，将我们创建对象的行为封装（因为创建对象的行为往往是重复的）然后直接调用工厂所给出的方法创建对象即可。 工厂模式有三种： 1. 简单工厂模式...
简单工厂模式_简单工厂模式_
10-02
运用两个典型案例，实现软件设计模式的简单工厂模式，从该案例中，可以体会简单工厂模式的特点
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1010
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 145
BCSP-X 11题 C++代码详解
【c++进阶(三)】STL之vector的介绍和使用
weixin_62196764的博客
06-15 693
1.vector表示的是可变序列大小的容器2、vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。3、vector与普通数组不同的是，vector的大小是可以动态改变的。4、当vector需要重新分配大小时，其做法是，分配一个新的数组，然后将全部元素移到这个数组当中，并释放原来的数组空间。---这就表明原来指向该位置的迭代器已经失效了，所以在插入和删除数据的时候要返回一个合法的迭代器的位置。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 324
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 292
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
【C++】 基础复习 ｜ 数据类型，输入，输出流 scanf printf
专注于人工智能的算法与应用
06-11 827
是 C 语言中两个非常重要的标准输入输出函数，它们分别用于从标准输入（通常是键盘）读取数据和向标准输出（通常是屏幕）打印数据。在这种情况下如果想控制输出，即满足一定格式输出，比如保留几位小数什么的，就要用manipulator了。需要变量的地址 ，即前面需要加一个&。函数用于从标准输入读取数据，并根据格式字符串解析这些数据。存储内存地址的变量。用户定义的复合数据类型，用于将不同类型的数据组合在一起。称做流式输入输出，
c++【入门】买文具2
LYK_0910的博客
06-11 134
花花去文具店买了1支笔和1块橡皮，已知笔x元/支，橡皮y元/块，花花付给了老板n元，请问老板应该找给花花多少钱？三个整数x、y、n，分别代表了笔的单价、橡皮的单价和花花付给老板的钱（已知花花付给老板的钱n>=x+y）。一个整数，代表老板应该找给花花的钱。内存限制 : 128 MB。时间限制 : 1 秒。
深度搜索算法3（c++）
mmz1207的博客
06-08 387
农夫约翰总是想要一个农场的地图，所以他拍摄了一张N行M列的卫星照片。一部分的照片看起来像这样： 他认为每个联通块都是一个谷仓或一头奶牛。农夫约翰认为一个联通块是谷仓，当且仅当它是一个完整的矩形，否则该联通块是一头奶牛。在下面的照片中，有三个谷仓（大小分别为2x1,2x5和1x1）和两头奶牛。计算他的卫星照片中谷仓和奶牛的数量。行2..N + 1：行i + 1表示照片的行i包含M个字 符（且不含空格）。行1：两个空格分隔的整数：N和M。行1：照片中的谷仓数量。行2：照片中的奶牛数量。
C++回溯算法
Yigeputongren的博客
06-11 98
【代码】C++回溯算法。
C++ 字符串处理5-手机号邮箱如何脱敏处理
最新发布
阳光日志
06-15 252
**关键词：** C++ 字符串处理 分割字符串 连接字符串 跨平台 **应用场景：** 有些重要信息需要保密，比如手机号、邮箱等，如何在不影响用户阅读的情况下，将这些信息脱敏处理，以保障用户的隐私安全。
C++ opengl 纹理映射
sss_brs的博客
06-12 106
老样子，改出来的，问GPT。
C++ Easyx案例实战：Cookie Maker工作室1.0V
快乐星空Maker的博客
06-09 723
有彩蛋！
C++:SLT容器--＞queue
坚持不懈的大白的博客
06-11 228
C++:SLT容器-->queue
C++中实现一个泄漏检测工具
道亦无名
06-09 75
在实际应用中，你可能需要更复杂的解决方案，比如使用现有的内存泄漏检测库（如Valgrind、AddressSanitizer等），它们提供了更强大和灵活的功能来处理各种内存管理问题。在C++中实现一个泄漏检测工具是一个复杂但有趣的任务。这通常涉及到重写或拦截内存分配和释放函数，以及跟踪所有内存分配的情况。处理函数或在全局对象的析构函数中执行上述检查，你可以在程序退出时打印出所有未释放的内存块的信息。这可能需要修改现有的代码或使用编译器特性来自动替换全局的。将上述代码集成到你的项目中，并确保所有使用。
工厂模式 python
03-07
工厂模式是一种常用的设计模式，它属于创建型模式，用于创建对象的过程中封装了对象的创建逻辑。在工厂模式中，我们通过使用工厂类来创建对象，而不是直接使用new关键字实例化对象。 在Python中，可以使用工厂模式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值