c++ 设计模式--简单工厂模式&工厂方法模式&抽象工厂模式(02,06,07)

最新推荐文章于 2022-08-17 21:50:35 发布
最新推荐文章于 2022-08-17 21:50:35 发布
阅读量192 收藏
点赞数
分类专栏： c++设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NiMiKiss/article/details/108289952
版权

案例 加减乘除运算

简单工厂模式(Sample Factory Pattern)

简单工厂模式定义

定义一个简单工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类

简单工厂模式结构

  • 工厂(Factory)：根据客户提供的具体产品类的参数，创建具体产品实例
  • 抽象产品(Abstract Product)：具体产品类的基类，包含创建产品的公共方法
  • 具体产品(Concrete Product)：抽象产品的派生类，包含具体产品特有的实现方法，是简单工厂模式的创建目标
    在这里插入图片描述

简单工厂模式示例

https://gitee.com/NiMiKiss/design-pattern.git

#ifndef _SAMPLE_FACTORY_PATTERN_
#define _SAMPLE_FACTORY_PATTERN_
#include <memory>

enum OperationType
{
	ADD = 0,
	SUB,
	MUL,
	DIV
};

template <typename T>
class Operation
{
public:
	void SetNum1(const T& num1) { m_iNum1 = num1; }
	void SetNum2(const T& num2) { m_iNum2 = num2; }
	T GetNum1()const { return m_iNum1; }
	T GetNum2()const { return m_iNum2; }
	virtual T GetResult() = 0;
private:
	T m_iNum1;
	T m_iNum2;
};

template <typename T>
class OperationAdd :public Operation<T>
{
public:
	T GetResult()
	{
		return Operation<T>::GetNum1() + Operation<T>::GetNum2();
	}
};

template <typename T>
class OperationSub :public Operation<T>
{
public:
	T GetResult()
	{
		return Operation<T>::GetNum1() - Operation<T>::GetNum2();
	}
};

template <typename T>
class OperationMul :public Operation<T>
{
public:
	T GetResult()
	{
		return Operation<T>::GetNum1() * Operation<T>::GetNum2();
	}
};

template <typename T>
class OperationDiv :public Operation<T>
{
public:
	T GetResult()
	{
		if (Operation<T>::GetNum2() != 0)
		{
			return Operation<T>::GetNum1() / Operation<T>::GetNum2();
		}
	}
};

template <typename T>
class OperationFactory
{
public:
	std::shared_ptr<Operation<T>> CreatOperation(OperationType eOperationType)
	{
		switch (eOperationType)
		{
		case ADD:
			return std::shared_ptr<OperationAdd<T>>(new OperationAdd<T>());
			break;
		case SUB:
			return std::shared_ptr<OperationSub<T>>(new OperationSub<T>());
			break;
		case MUL:
			return std::shared_ptr<OperationMul<T>>(new OperationMul<T>());
		case DIV:
			return std::shared_ptr<OperationDiv<T>>(new OperationDiv<T>());
		default:
			break;
		}
	}
};
#endif // !_SAMPLE_FACTORY_PATTERN_

客户端调用

#include"Operation.h"
#include<iostream>

int main()
{
	auto operationFactory = std::shared_ptr<OperationFactory<int>>(new OperationFactory<int>());
	auto operation = operationFactory->CreatOperation(SUB);
	operation->SetNum1(1);
	operation->SetNum2(3);
	std::cout<<operation->GetResult();
	return EXIT_SUCCESS;
}

工厂方法模式(Factory Method)

工厂方法模式定义

定义一个用于创建对象的接口，让子类决定用哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类

工厂方法模式结构

  • 抽象工厂(AbstractFactory): 所有生产具体产品的工厂类的基类，提供工厂类的公共方法
  • 具体工厂(ConcreteFactory):生产具体的产品
  • 抽象产品(AbstractProduct):所有产品的基类，提供产品类的公共方法
  • 具体产品(ConcreteProduct):具体产品类
    在这里插入图片描述

工厂方法模式示例

https://gitee.com/NiMiKiss/design-pattern.git

#ifndef _FACTORY_METHOD_PATTERN_
#define _FACTORY_METHOD_PATTERN_
#include <memory>

enum OperationType
{
	ADD = 0,
	SUB,
	MUL,
	DIV
};

template <typename T>
class Operation
{
public:
	void SetNum1(const T& num1) { m_iNum1 = num1; }
	void SetNum2(const T& num2) { m_iNum2 = num2; }
	T GetNum1()const { return m_iNum1; }
	T GetNum2()const { return m_iNum2; }
	virtual T GetResult() = 0;
private:
	T m_iNum1;
	T m_iNum2;
};

template <typename T>
class OperationAdd :public Operation<T>
{
public:
	T GetResult()
	{
		return Operation<T>::GetNum1() + Operation<T>::GetNum2();
	}
};

template <typename T>
class OperationSub :public Operation<T>
{
public:
	T GetResult()
	{
		return Operation<T>::GetNum1() - Operation<T>::GetNum2();
	}
};

template <typename T>
class OperationMul :public Operation<T>
{
public:
	T GetResult()
	{
		return Operation<T>::GetNum1() * Operation<T>::GetNum2();
	}
};

template <typename T>
class OperationDiv :public Operation<T>
{
public:
	T GetResult()
	{
		if (Operation<T>::GetNum2() != 0)
		{
			return Operation<T>::GetNum1() / Operation<T>::GetNum2();
		}
	}
};

template <typename T>
class OperationFactory
{
public:
	virtual std::shared_ptr<Operation<T>> CreatOperation() = 0;
};

template <typename T>
class OperationAddFactory
{
public:
	std::shared_ptr<Operation<T>> CreatOperation()
	{
		return std::shared_ptr<OperationAdd<T>>(new OperationAdd<T>());
	}
};

template <typename T>
class OperationSubFactory
{
public:
	std::shared_ptr<Operation<T>> CreatOperation()
	{
		return std::shared_ptr<OperationSub<T>>(new OperationSub<T>());
	}
};

template <typename T>
class OperationMulFactory
{
public:
	std::shared_ptr<Operation<T>> CreatOperation()
	{
		return std::shared_ptr<OperationMul<T>>(new OperationMul<T>());
	}
};

template <typename T>
class OperationDivFactory
{
public:
	std::shared_ptr<Operation<T>> CreatOperation()
	{
		return std::shared_ptr<OperationDiv<T>>(new OperationDiv<T>());
	}
};

#endif // !_FACTORY_METHOD_PATTERN_

客户端调用

#include "Factory_Method_Pattern.h"
#include<iostream>
#include<memory>
int main()
{
	auto operationAddFactory = std::shared_ptr<OperationAddFactory<int>>(new OperationAddFactory<int>());
	auto operationAdd = operationAddFactory->CreatOperation();
	operationAdd->SetNum1(1);
	operationAdd->SetNum2(3);
	std::cout << operationAdd->GetResult();
	return EXIT_SUCCESS;
}

案例 在Access和SQL server分别插入User表和Department表

抽象工厂模式

抽象工厂模式定义

提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类

抽象工厂模式结构

  • 抽象工厂(AbstractFactory): 所有生产具体产品的工厂类的基类，提供工厂类的公共方法
  • 具体工厂(ConcreteFactory):生产具体的产品
  • 抽象产品(AbstractProduct):所有产品的基类，提供产品类的公共方法
  • 具体产品(ConcreteProduct):具体产品类
    在这里插入图片描述

抽象工厂模式示例

https://gitee.com/NiMiKiss/design-pattern.git

#ifndef _ABSTRACT_FACTORY_PATTERN
#define _ABSTRACT_FACTORY_PATTERN
#include<iostream>
#include<map>
class User
{
public:
	User(const std::string& sName = "", int iID = 0) :m_sName(sName), m_iID(iID) {};
	void SetName(const std::string& sName) { m_sName = sName; }
	std::string GetName()const { return m_sName; }
	void SetId(int iID) { m_iID = iID; }
	int GetID()const { return m_iID; }
private:
	std::string m_sName;
	int m_iID;
};

class IUser
{
public:
	virtual void InsertUser(const User& user)
	{
		std::cout << "Name = " << user.GetName() << " ID= " << user.GetID() << std::endl;
		m_mapUser.insert(std::make_pair(user.GetID(), user));
	};
	virtual void GetUserByID(int iID, User& user)
	{
		if (m_mapUser.find(iID) != m_mapUser.end())
		{
			user = m_mapUser[iID];
			std::cout << "Name = " << user.GetName() << " ID= " << user.GetID() << std::endl;
		}
	}
private:
	std::map<int, User> m_mapUser;
};

class SqlServerUser :public IUser
{
public:
	void InsertUser(const User& user)
	{
		std::cout << "在SQL Server中给User表增加了一条记录:" << std::endl;
		IUser::InsertUser(user);
	}
	void GetUserByID(int iID, User& user)
	{
		std::cout << "在SQL Server中根据ID得到User表一条记录" << std::endl;
		IUser::GetUserByID(iID, user);
	}
};

class AccessUser :public IUser
{
public:
	void InsertUser(const User& user)
	{
		std::cout << "在Access中给User表增加了一条记录" << std::endl;
		IUser::InsertUser(user);
	}
	void GetUserByID(int iID, User& user)
	{
		std::cout << "在Access中根据ID得到User表一条记录" << std::endl;
		IUser::GetUserByID(iID, user);
	}
};

class Department
{
public:
	Department(const std::string& sName = "", int iID = 0) :m_sName(sName), m_iID(iID) {};
	void SetName(const std::string& sName) { m_sName = sName; }
	std::string GetName()const { return m_sName; }
	void SetId(int iID) { m_iID = iID; }
	int GetID()const { return m_iID; }
private:
	std::string m_sName;
	int m_iID;
};

class IDepartment
{
public:
	virtual void InsertDepartment(const Department& department)
	{
		std::cout << "Name = " << department.GetName() << " ID= " << department.GetID() << std::endl;
		m_mapDepartment.insert(std::make_pair(department.GetID(), department));
	};
	virtual void GetDepartmentByID(int iID, Department& department)
	{
		if (m_mapDepartment.find(iID) != m_mapDepartment.end())
		{
			department = m_mapDepartment[iID];
			std::cout << "Name = " << department.GetName() << " ID= " << department.GetID() << std::endl;
		}
	}
private:
	std::map<int, Department> m_mapDepartment;
};

class SqlServerDepartment :public IDepartment
{
public:
	void InsertDepartment(const Department& department)
	{
		std::cout << "在SQL Server中给Department表增加了一条记录:" << std::endl;
		IDepartment::InsertDepartment(department);
	}
	void GetDepartmentByID(int iID, Department& department)
	{
		std::cout << "在SQL Server中根据ID得到Department表一条记录" << std::endl;
		IDepartment::GetDepartmentByID(iID, department);
	}
};

class AccessDepartment :public IDepartment
{
public:
	void InsertDepartment(const Department& department)
	{
		std::cout << "在Access中给Department表增加了一条记录" << std::endl;
		IDepartment::InsertDepartment(department);
	}
	void GetDepartmentByID(int iID, Department& department)
	{
		std::cout << "在Access中根据ID得到Department表一条记录" << std::endl;
		IDepartment::GetDepartmentByID(iID, department);
	}
};

class Factory
{
public:
	virtual std::shared_ptr<IUser> CreatUser() = 0;
	virtual std::shared_ptr<IDepartment> CreatDepartment() = 0;
};

class SqlServerFactory :public Factory
{
public:
	std::shared_ptr<IUser> CreatUser()
	{
		return std::shared_ptr<SqlServerUser>(new SqlServerUser());
	}
	std::shared_ptr<IDepartment> CreatDepartment()
	{
		return std::shared_ptr<SqlServerDepartment>(new SqlServerDepartment());
	}
};

class AccessFactory :public Factory
{
public:
	std::shared_ptr<IUser> CreatUser()
	{
		return std::shared_ptr<AccessUser>(new AccessUser());
	}
	std::shared_ptr<IDepartment> CreatDepartment()
	{
		return std::shared_ptr<AccessDepartment>(new AccessDepartment());
	}
};
#endif // !_ABSTRACT_FACTORY_PATTERN

客户端调用

#include "Abstract_Factory_Pattern.h"
#include<memory>
#include<iostream>

void TestAccessUser()
{
	auto spAccessFactory = std::shared_ptr<AccessFactory>(new AccessFactory());
	auto spAccessUser = spAccessFactory->CreatUser();
	spAccessUser->InsertUser(User("小白", 1));
	User userGet;
	spAccessUser->GetUserByID(1, userGet);
	std::cout << "客户端获取：ID= " << userGet.GetID() << " Name=" << userGet.GetName() << std::endl;
}

void TestSqlServerUser()
{
	auto spSqlServerFactory = std::shared_ptr<SqlServerFactory>(new SqlServerFactory());
	auto spSqlServerUser = spSqlServerFactory->CreatUser();
	spSqlServerUser->InsertUser(User("小白", 1));
	User userGet;
	spSqlServerUser->GetUserByID(1, userGet);
	std::cout << "客户端获取：ID= " << userGet.GetID() << " Name=" << userGet.GetName() << std::endl;
}

void TestAccessDepartment()
{
	auto spAccessFactory = std::shared_ptr<AccessFactory>(new AccessFactory());
	auto spAccessDepartment = spAccessFactory->CreatDepartment();
	spAccessDepartment->InsertDepartment(Department("小白", 1));
	Department departmentGet;
	spAccessDepartment->GetDepartmentByID(1, departmentGet);
	std::cout << "客户端获取：ID= " << departmentGet.GetID() << " Name=" << departmentGet.GetName() << std::endl;
}

void TestSqlServerDepartment()
{
	auto spSqlServerFactory = std::shared_ptr<SqlServerFactory>(new SqlServerFactory());
	auto spSqlServerDepartment = spSqlServerFactory->CreatDepartment();
	spSqlServerDepartment->InsertDepartment(Department("小白", 1));
	Department departmentGet;
	spSqlServerDepartment->GetDepartmentByID(1, departmentGet);
	std::cout << "客户端获取：ID= " << departmentGet.GetID() << " Name=" << departmentGet.GetName() << std::endl;
}

int main()
{
	TestAccessUser();
	TestSqlServerUser();
	
	TestAccessDepartment();
	TestSqlServerDepartment();
	return EXIT_SUCCESS;
}
阿狸灬小丸子
关注
专栏目录
C++设计模式 - 简单工厂，工厂方法和抽象工厂
大秦坑王的专栏
03-26 1986
知识的学习在于点滴记录，坚持不懈；知识的学习要有深度和广度，不能只流于表面，坐井观天；知识要善于总结，不仅能够理解，更知道如何表达！ 目录 如果需要录屏资料，请私信邮箱shitou3000@qq.com获取。 ...
最常用的设计模式----工厂模式家族（简单工厂模式， 工厂方法模式， 抽象工厂模式）
黄花寒
11-08 3723
工厂模式是个系列，分为简单工厂模式， 工厂模式， 抽象工厂模式，这三种模式也非常常用。这些模式最最经典的就例子就是设计计算器。      简单工厂模式          严格的说，简单工厂模式并不是23种常用的设计模式之一，它只算工厂模式的一个特殊实现。简单工厂模式在实际中的应用相对于其他2个工厂模式用的还是相对少得多，因为它只适应很多简单的情况，最最重要的是它违背了我们在概述中说的开放-封闭
设计模式之简单工厂模式、工厂方法模式、抽象工厂模式（C++）
qq_39220334的博客
08-17 715
简单工厂模式里通常包含一个工厂类，用于创建实例。包含一个抽象类以及多个具体类。向工厂类中传入参数，工厂类就可以实例化出具体的对象。
C++常见设计模式之工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式）
scarificed的博客
11-12 1703
1、工厂模式属于创建型模式 ，大致分为3类：简单工厂模式 、工厂方法模式、 抽象工厂模式。 2、简单工厂模式：需要在工厂类中做出判断，从而创造出相应的产品，当增加新产品时，就需要修改工厂类。 //有一家生产处理器核的厂家，它只有一个工厂(1个类)，能够生产两种单核处理器核（2个类，两种处理器某些共同特点，1个父类） //客户需要什么样的处理器，一定要显示的告诉生产工厂。 enum CTYPE{TYPEA ,TYPEB}; class Product { public: virtual void Sho
抽象工厂模式（Abstract Factory）
黑色幽默
03-29 861
概述 在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时由于需求的变化，往往存在着更多系列对象的创建工作。如何应对这种变化？如何绕过常规的对象的创建方法（new），提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？这就是我们要说的抽象工厂模式。 意图 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 模型图 逻辑模型： 物
c++设计模式-抽象工厂方法
06-04
**抽象工厂方法（Abstract Factory Pattern）**是一种创建型设计模式，它提供了一种创建对象族的接口，而具体的对象族由子类决定。在C++中，这种模式可以帮助我们隔离对象的创建和使用，使得代码更加灵活，易于扩展...
c++设计模式-工厂方法模式
06-04
在标题“c++设计模式-工厂方法模式”中，我们关注的是如何在C++中实现工厂方法这一设计模式。工厂方法模式的核心思想是定义一个创建对象的接口，但让子类决定实例化哪一个类。这样，工厂方法可以使类的实例化过程...
设计模式之抽象工厂模式-c++
最新发布
09-18
抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，提供一个接口用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。这种模式常用于需要跨多个产品系列进行实例化的场景。 抽象工厂模式的...
C++ 设计模式：简单工厂、工厂方法、抽象工厂练习代码
05-24
- C++中，工厂方法模式通常通过定义一个抽象工厂类，它声明了一个或多个虚函数，每个函数对应一种产品类型。然后，每个具体工厂子类实现这些虚函数，生成特定的产品实例。 - 这种模式增强了系统的灵活性，当需要...
《C++20设计模式》学习笔记-第3章工厂方法和抽象工厂模式学习代码
02-04
《C++20设计模式》学习笔记-第3章工厂方法和抽象工厂模式学习代码
C++ 工厂模式 （简单工厂、工厂和抽象工厂）
08-12
C++ 工厂模式 （简单工厂、工厂和抽象工厂）
C#设计模式编程之抽象工厂模式新解
cxzhq2002的杂记
06-27 921
C#设计模式编程之抽象工厂模式新解 作者： terrylee
C++ 工厂模式(简单工厂模式、工厂方法模式、抽象工厂模式)
cleverlemon的博客
07-06 1004
  利用工厂模式来生成对象，不需要关注对象的生成过程；还可以简化名称，以便使用。 简单工厂模式   同一工厂生产多个产品。   违背开放–封闭规则（开放指新版本设计时可以使用旧版本的代码；封闭指不能修改旧版本的代码）。因此适用于规模固定、不易发生产品改动的工厂。实现如下： //简单工厂模式 #include<iostream> class Fruit { public: Fruit(std::string nm) :mname(nm) {} virtual
设计模式（3）：抽象工厂模式及其在Java框架中的应用示例
qq_41969790的博客
08-01 703
抽象工厂模式 1、什么是抽象工厂模式？ 2、抽象工厂模式特性？ 3、抽象工厂模式的优缺点及应用场景 4、抽象工厂模式实现示例 5、JDK中抽象工厂模式的典型应用示例 1、什么是抽象工厂模式？ 抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对
Java设计模式菜鸟系列(五)抽象工厂模式建模与实现
JAVE_LOVER
10-04 172
转载请注明出处：http://blog.csdn.net/lhy_ycu/article/details/39784403   抽象工厂模式（Abstract Factory）：抽象工厂--顾名思义，就是把工厂抽象出来，不同的工厂生产不同的产品。这样做有个好处：一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。   一、uml建模图：   二、代码实现 ...
抽象工厂模式[wiki]
weixin_34381666的博客
10-10 120
抽象工厂[编辑] 维基百科，自由的百科全书 跳转至： 导航、 搜索 以统一塑模语言中的类型图来表示抽象工厂 抽象工厂模式（英语：Abstract factory pattern）是一种软件开发设计模式。抽象工厂模式提供了一种方式，可以将一组具有同一主题的单独的工厂封装起来。在正常使用中，客户端程序需要创建抽象工厂的具...
三种工厂模式的实例化应用
qq_42272391的博客
05-04 1916
1.实验目的 a．熟悉建模工具。 b. 掌握简单工厂模式、工厂方法模式、抽象工厂模式，并进行设计应用。 2.题目描述 1.简单工厂模式 使用简单工厂模式模拟女娲（Nvwa）造人（Person），如果传入参数M，则返回一个Man对象，如果传入参数W，则返回一个Woman对象，请实现该场景。现需要增加一个新的R...
抽象工厂模式模型图
xungxingzhihuolc的博客
06-19 225
设计模式：抽象工厂模式
weixin_45753689的博客
08-30 84
②抽象工厂模式（Abstract Factory Pattern） 简介： ​ 抽象工厂模式是围绕一个超级工厂创建其他工厂，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 实现方法： 创建产品接口，产品实现类实现接口。 创建抽象工厂，普通工厂类继承抽象工厂，重写方法，扩展生产产品的方法。 创建超级工厂，用来生产普通工厂类。 通过不同的条件，使超级工厂生成相应的普通工厂类，进而生成产品对象。 优点： ​ 当一个产品族中的多个对象被设计成一起工作时，抽象工厂模式可以保证客户端始终只使
C++设计模式：简单工厂与工厂方法模式对比分析
"C++设计模式中的简单工厂与工厂方法模式是两种常见的创建型设计模式，它们在软件开发中用于抽象产品的创建过程。这两种模式都旨在将对象的创建与使用分离，使得代码更具可扩展性和可维护性。下面将详细介绍这两种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值