设计模式之工厂模式(C++)

已于 2023-02-16 11:32:01 修改
阅读量2.5w 收藏 23
点赞数 10
分类专栏： C++ 文章标签： c++ 设计模式 工厂模式
于 2023-02-15 16:59:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaitianbao/article/details/129042599
版权

作者：翟天保Steven
版权声明：著作权归作者所有，商业转载请联系作者获得授权，非商业转载请注明出处

一、工厂模式是什么？

       工厂模式是一种创建型的软件设计模式。定义一个用于创建对象的工厂接口，并让工厂子类决定实例化哪一个产品类，使产品类的实例化延迟到工厂子类中执行。说白了就是用来造东西的，一般是比较简单的东西，我们不需要知道它如何生产的，直接从工厂拿到产品即可。

       工厂模式的优点：

  1. 良好的封装性。将产品的实例化封装执行，避免被修改，这样的产品具备良好的一致性。
  2. 良好的扩展性。增加产品时，同步增加一个工厂子类，不会违反开闭原则。
  3. 标准的解耦合框架。使用者只需要知道自己要什么产品即可，不用去管产品具体的特性等等，降低了模块间的耦合。

      工厂模式的缺点：

  1. 代码量大。每加一个产品，都要加一个工厂子类，代码会显得臃肿。
  2. 不利于扩展复杂的产品结构。如果你要苹果、香蕉、梨，工厂模式的结构还可以，但如果你要山东的苹果、海南的香蕉、北京的苹果，就显得结构呆呆的。这可以用抽象工厂模式解决，对产品族和产品种类进行区分。

二、简单工厂模式

       在介绍工厂模式前，先介绍其前身-简单工厂模式，简单工厂模式是用一个简单的工厂类，直接对产品进行实例化，虽然大大减少了代码量，但是违反了设计中的开闭原则，因为每次添加产品，工厂类都要进行修改。

2.1 结构图

       客户端即Main主函数，调用简单工厂制造产品，并获取产品。具体要什么产品由客户端命令决定。

 2.2 代码示例

       场景描述：我联系了一个生产水果的工厂，从工厂拿了一个苹果、一个香蕉和一个梨，用来果腹，工厂给我一个报价我付钱即可。

//Prodect.h
/****************************************************/
#pragma once
#include <iostream>

using namespace std;

// 产品种类
enum PRODECT_TYPE
{
	APPLE,                     // 苹果
	BANANA,					   // 香蕉
	PEAR					   // 梨
};

// 抽象产品类
class Prodect
{
public:
	// 构造函数
	Prodect(int price) :m_price(price) {};
	// 析构函数
	virtual ~Prodect() {};
	// 获取价格
	int getPrice() {
		return m_price;
	}
protected:
	// 产品价格
	int m_price;
};

// 具体产品类-苹果
class AppleProdect : public Prodect
{
public:
	// 构造函数
	AppleProdect(int price) :Prodect(price) {
		cout << "获得了一个苹果。" << endl;
	};
	// 析构函数
	virtual ~AppleProdect() {
		cout << "吃掉了一个苹果。" << endl;
	};
};

// 具体产品类-香蕉
class BananaProdect : public Prodect
{
public:
	// 构造函数
	BananaProdect(int price) :Prodect(price) {
		cout << "获得了一个香蕉。" << endl;
	};
	// 析构函数
	virtual ~BananaProdect() {
		cout << "吃掉了一个香蕉。" << endl;
	};
};

// 具体产品类-梨
class PearProdect : public Prodect
{
public:
	// 构造函数
	PearProdect(int price) :Prodect(price) {
		cout << "获得了一个梨。" << endl;
	};
	// 析构函数
	virtual ~PearProdect() {
		cout << "吃掉了一个梨。" << endl;
	};
};


//Factory.h
/****************************************************/
#pragma once
#include <iostream>
#include "Prodect.h"

using namespace std;

// 简单工厂
class SimpleFactory
{
public:
	// 获取产品
	Prodect* getProdect(PRODECT_TYPE type) {
		Prodect* prodect = nullptr;
		switch (type)
		{
		case APPLE:
			prodect = new AppleProdect(5);
			break;
		case BANANA:
			prodect = new BananaProdect(2);
			break;
		case PEAR:
			prodect = new PearProdect(3);
			break;
		default:
			cout << "无该产品。" << endl;
			break;
		}
		return prodect;
	}
};


//main.cpp
/****************************************************/
#include <iostream>
#include "Factory.h"
#include "Prodect.h"

using namespace std;

int main()
{
	SimpleFactory* factory = new SimpleFactory();
	cout << "开始生产。" << endl;
	Prodect *A = factory->getProdect(APPLE);
	Prodect *B = factory->getProdect(BANANA);
	Prodect *C = factory->getProdect(PEAR);
	int applePrice = A->getPrice();
	int bananaPrice = B->getPrice();
	int pearPrice = C->getPrice();
	int sum = A->getPrice() + B->getPrice() + C->getPrice();
	cout << "苹果价格：" << applePrice << "元。" << endl;
	cout << "香蕉价格：" << bananaPrice << "元。" << endl;
	cout << "梨子价格：" << pearPrice << "元。" << endl;
	cout << "累计消费：" << sum << "元。" << endl;
	delete A;
	delete B;
	delete C;
    delete factory;
	cout << "享用完毕。" << endl;
	return 0;
}

       程序结果如下。

        在上述示例中，我们可以看到，如果我想给工厂再添加一个产品，那么除了添加一个产品子类外，还要跑到简单工厂的类中进行switch的扩展，这样不利于代码的封装，破坏了开闭原则。而工厂模式的设计能弥补该不足。

三、工厂模式

3.1 结构图

       客户端即Main主函数，通过工厂子类来制造对应的产品，并获取产品。具体要什么产品由工厂子类决定。

 3.2 代码示例

       场景描述：我联系了一个生产水果的工厂，从工厂拿了一个苹果、一个香蕉和一个梨，用来果腹，工厂给我一个报价我付钱即可。

//Prodect.h
/****************************************************/
#pragma once
#include <iostream>

using namespace std;

// 抽象产品类
class Prodect
{
public:
	// 构造函数
	Prodect(int price) :m_price(price) {};
	// 析构函数
	virtual ~Prodect() {};
	// 获取价格
	int getPrice() {
		return m_price;
	}
protected:
	// 产品价格
	int m_price;
};

// 具体产品类-苹果
class AppleProdect : public Prodect
{
public:
	// 构造函数
	AppleProdect(int price) :Prodect(price) {
		cout << "获得了一个苹果。" << endl;
	};
	// 析构函数
	virtual ~AppleProdect() {
		cout << "吃掉了一个苹果。" << endl;
	};
};

// 具体产品类-香蕉
class BananaProdect : public Prodect
{
public:
	// 构造函数
	BananaProdect(int price) :Prodect(price) {
		cout << "获得了一个香蕉。" << endl;
	};
	// 析构函数
	virtual ~BananaProdect() {
		cout << "吃掉了一个香蕉。" << endl;
	};
};

// 具体产品类-梨
class PearProdect : public Prodect
{
public:
	// 构造函数
	PearProdect(int price) :Prodect(price) {
		cout << "获得了一个梨。" << endl;
	};
	// 析构函数
	virtual ~PearProdect() {
		cout << "吃掉了一个梨。" << endl;
	};
};


//Factory.h
/****************************************************/
#pragma once
#include <iostream>
#include "Prodect.h"

using namespace std;

// 抽象工厂类
class Factory
{
public:
	// 获取产品
	virtual Prodect* getProdect() = 0;
};

// 具体工厂类-苹果
class AppleFactory : public Factory
{
public:
	// 获取产品
	virtual Prodect* getProdect() {
		Prodect* prodect = new AppleProdect(5);
		return prodect;
	}
};

// 具体工厂类-香蕉
class BananaFactory : public Factory
{
public:
	// 获取产品
	virtual Prodect* getProdect() {
		Prodect* prodect = new BananaProdect(2);
		return prodect;
	}
};

// 具体工厂类-梨
class PearFactory : public Factory
{
public:
	// 获取产品
	virtual Prodect* getProdect() {
		Prodect* prodect = new PearProdect(3);
		return prodect;
	}
};


//main.cpp
/****************************************************/
#include <iostream>
#include "Factory.h"
#include "Prodect.h"

using namespace std;

int main()
{
	Factory* factoryA = new AppleFactory();
	Factory* factoryB = new BananaFactory();
	Factory* factoryC = new PearFactory();
	cout << "开始生产。" << endl;
	Prodect *A = factoryA->getProdect();
	Prodect *B = factoryB->getProdect();
	Prodect *C = factoryC->getProdect();
	int applePrice = A->getPrice();
	int bananaPrice = B->getPrice();
	int pearPrice = C->getPrice();
	int sum = A->getPrice() + B->getPrice() + C->getPrice();
	cout << "苹果价格：" << applePrice << "元。" << endl;
	cout << "香蕉价格：" << bananaPrice << "元。" << endl;
	cout << "梨子价格：" << pearPrice << "元。" << endl;
	cout << "累计消费：" << sum << "元。" << endl;
	delete A;
	delete B;
	delete C;
    delete factoryA;
    delete factoryB;
    delete factoryC;
	cout << "享用完毕。" << endl;
	return 0;
}

       程序结果如下。

        这样设计的好处就是如果多一个产品，那就只需要在产品类和工厂类中各扩展一个子类即可，不影响原有的程序。

四、总结

       我尽可能用较通俗的话语和直观的代码例程，来表述我对工厂模式的理解，或许有考虑不周到的地方，如果你有不同看法欢迎评论区交流！希望我举的例子能帮助你更好地理解工厂模式。

       如果文章帮助到你了，可以点个赞让我知道，我会很快乐~加油！

翟天保Steven
关注
  • 10
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
一个工厂模式的例子（C++实现）
04-26
这是用C++写的一个工厂模式的例子，以创建不同子公司为例，教你如何创建工厂模式
c++设计模式之工厂模式
weixin_30614109的博客
03-13 109
1：简单工厂模式 　　简单工厂模式是属于创建型模式，又叫做静态工厂方法(static Factory Method)模式，简单工厂模式是由一个工厂对象决定创建出来哪一种产品类的实例. 　　简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一类产品类(这些产品类继承自一个父类或接口)的实例。打个比方 　　假设有一个工厂，他能生产出A、B两种产品。当客户需要产品的时候一定要告诉共...
C++设计模式——简单工厂模式
weixin_30567225的博客
03-31 320
问题描述 之前在公司做了一个windows 8平台的阅读器。首先，需要将电子书中的内容渲染到屏幕上，而电子书每一页都包含各种各样的内容，比如：图形、图像和文字等等；不同的内容，就是不同的对象；在将不同的内容渲染到屏幕上之前，就需要new操作，建立不同的对象，然后再在屏幕上进行描绘。这个时候，就需要进行很多new操作，new操作分布在代码的不同地方，管理起来很麻烦，而且也很乱，到后期扩展和维护的时...
C++设计模式——工厂模式
Abieai的博客
10-14 796
设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。本文主要实现了简单工厂和抽象工厂。
C++设计模式 -- 工厂模式
欧特GO
06-10 359
工厂方法模式
C++设计模式之工厂方法模式
12-31
之前讲到了C++设计模式——简单工厂模式，由于简单工厂模式的局限性，比如：工厂现在能生产ProductA、ProductB和ProductC三种产品了，此时，需要增加生产ProductD产品；那么，首先是不是需要在产品枚举类型中添加新...
c++设计模式-工厂方法模式
06-04
c++设计模式-创建型模式-工厂方法模式-最简单的源码-qt工程
C++设计模式之工厂模式
01-20
由遇到的问题引出工厂模式 在面向对象系统设计中经常可以遇到以下的两类问题： ◆ 1.为了提高内聚（Cohesion）和松耦合（Coupling），我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过...
C++的设计模式之工厂方法模式（Factory Method）
最新发布
02-28
C++的设计模式之工厂方法模式（Factory Method） C++的设计模式之工厂方法模式（Factory Method） C++的设计模式之工厂方法模式（Factory Method） C++的设计模式之工厂方法模式（Factory Method）
C++设计模式-工厂模式
IT1995的博客
06-13 6678
目录 基本概念 代码及实例 基本概念 工厂方法模式（Factory Method）：定义一个用于创建对象的接口，让字类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类； 简单工厂模式的最大优点在用户工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了具体产品的依赖。 工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实...
c++ 设计模式 --- 工厂模式
weixin_60569662的博客
06-15 621
和简单工厂模式区别不大，只是为工厂提供了一个抽象方法：c++ 设计模式 --- 单例模式、简单工厂_小雪菜本菜的博客-CSDN博客_c++单例工厂工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是 定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。 核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类 必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工 厂角色的情况下引进新的产品工厂方法模式与简单工厂模式在结构
太香了！TypeScript 工厂方法模式（文未送福利）
奎特尔星球
09-21 277
在现实生活中，工厂是负责生产产品的，比如牛奶、面包或礼物等，这些产品满足了我们日常的生理需求。此外，在日常生活中，我们也离不开大大小小的系统，这些系统是由不同的组件对象构成。（文末有送书...
c++ 工厂设计模式
Anurmy的博客
02-19 703
1 定义 所谓简单工厂模式，是一种实例化对象的方式，只要输入需要实例化对象的名字，就可以通过工厂对象的相应工厂函数来制造你需要的对象。 简单工厂模式的核心是，对于一个父类的多个继承子类，工厂对象的工厂函数根据用户输入，自动new出一个子类对象并返回其父类的指针，这样利用父类的指针执行父类的虚函数，就可以动态绑定子类的重写函数，从而实现多态。 2 代码实现 #ifndef __SIMPLEFACTORY__H #define __SIMPLEFACTORY__H #include <iostream&
C++工厂设计模式
芒种、的博客
07-16 708
一、工厂模式 工厂模式包括三种：简单工厂模式、工厂方法模式、抽象工厂模式。 工厂模式的主要作用是封装对象的创建，分离对象的创建和操作过程，用于批量管理对象的创建过程，便于程序的维护和扩展。 1.简单工厂模式 核心思想：是用一个工厂来根据输入的条件产生不同的类，然后根据不同类的 virtual 函数得到不同的结果，只抽象产品，不抽象工厂 #include "stdafx.h" #include <iostream> using namespace std; //计算基类 class Operat
将多个cpp文件封装成so
06-02
好的，下面是将多个 C++ 文件封装成一个动态库的步骤： 1. 编写多个 C++ 文件，例如 `hello.cpp` 和 `world.cpp`： ```cpp // hello.cpp #include <iostream> void hello() { std::cout << "Hello, "; } // world.cpp #include <iostream> void world() { std::cout << "world!" << std::endl; } ``` 2. 使用 `-c` 选项分别将这些文件编译成目标文件，例如： ```bash g++ -c hello.cpp g++ -c world.cpp ``` 这里的 `-c` 选项表示只编译成目标文件，不链接生成可执行文件。 3. 将这些目标文件链接成一个动态库，使用下面的命令： ```bash g++ -shared -fPIC hello.o world.o -o libhelloworld.so ``` 这里的 `-shared` 选项表示编译成动态库，`-fPIC` 表示生成位置无关代码，`-o` 指定输出文件名。 4. 测试动态库，编写测试代码： ```cpp #include <dlfcn.h> int main() { void *handle = dlopen("./libhelloworld.so", RTLD_LAZY); if (!handle) { std::cerr << dlerror() << std::endl; return 1; } typedef void (*hello_t)(); hello_t hello = (hello_t) dlsym(handle, "hello"); if (!hello) { std::cerr << dlerror() << std::endl; return 1; } typedef void (*world_t)(); world_t world = (world_t) dlsym(handle, "world"); if (!world) { std::cerr << dlerror() << std::endl; return 1; } hello(); world(); dlclose(handle); return 0; } ``` 这里使用 `dlopen` 打开动态库，`dlsym` 获取导出函数地址，然后调用导出函数。 5. 编译测试代码，使用下面的命令： ```bash g++ test.cpp -ldl -o test ``` 这里的 `-ldl` 选项表示链接动态链接器。 6. 运行测试程序，使用下面的命令： ```bash ./test ``` 如果一切正常，就会输出 `Hello, world!`。 这样就成功将多个 C++ 文件封装成一个动态库，并且测试了动态库的导出函数。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

翟天保Steven

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值