《大话设计模式》C++实现：01 简单工厂模式

文章目录

• • 1. 什么是简单工厂模式？
  • 2. 简单工厂模式的适用场景？
  • • 2.1 优点
    • 2.2 缺点
  • 3. 怎样使用简单工厂模式？
  • • 3.1 方法
    • 3.2 UML类图
  • 4. 实例
  • • 4.1 结果（结论先行）
    • 4.2 具体实现
    • • 4.2.1 简单工厂的静态接口
      • 4.2.2 四则运算符继承体系代码

1. 什么是简单工厂模式？

当出现批量化的产品时，使用单独的类创建每个产品，实现去实例化对象。

2. 简单工厂模式的适用场景？

优缺点有参考这篇博客：简单工厂和工厂方法模式

2.1 优点

1、降低了客户与具体实现的耦合（相较不使用简单工厂而言）。

封装了细节，客户只需调用工厂接口，不必关心如何创建产品，只关心使用产品；

2.2 缺点

1、工厂类对产品的耦合较强

集中了所有产品的创建逻辑，模块与模块之间耦合在一个类里。 工厂崩、系统也崩；

2、违反“开放-关闭原则”

添加新产品，除了添加新产品代码外，还需要修改工厂逻辑，添加分支处理；

3. 怎样使用简单工厂模式？

3.1 方法

以四则运算器工厂为例：

1、简单工厂类提供静态方法，通过

swich...case...

生成对应运算器实例。

返回运算器的基类，将分支的子类指针赋值给了基类，实现客户与具体产品的解耦。

2、提供运算器基类，实现通用方法，提供抽象的结果纯虚接口

getResult()

。

3、加减乘除子类分别实现

getResult()

接口，应用了多态运行时生成对象的特点，通过基类指针调用该接口，完成客户端加减乘除功能的实现。

3.2 UML类图

4. 实例

4.1 结果（结论先行）

4.1.1 main.cpp

#include "Operation.h"
#include "OperationFactory.h"
using namespace std;

void test()
{
	double numA = 20, numB = 10;
	cout << "A = " << numA << "\tB = " << numB << endl;

	Operation* oper = OperationFactory::createOperation('+');
	oper->setNumberA(numA);
	oper->setNumberB(numB);
	cout << "add result = " << oper->getResult() << endl;

	oper = OperationFactory::createOperation('-');
	oper->setNumberA(numA);
	oper->setNumberB(numB);
	cout << "sub result = " << oper->getResult() << endl;

	oper = OperationFactory::createOperation('*');
	oper->setNumberA(numA);
	oper->setNumberB(numB);
	cout << "mul result = " << oper->getResult() << endl;

	oper = OperationFactory::createOperation('/');
	oper->setNumberA(numA);
	oper->setNumberB(numB);
	cout << "div result = " << oper->getResult() << endl;
}

int main()
{
	test();
	system("pause");
	return 0;
}
           

4.2 具体实现

4.2.1 简单工厂的静态接口

1、OperationFactory.h

#pragma once
#include "Operation.h"
#include "OperationAdd.h"
#include "OperationMul.h"
#include "OperationDiv.h"
#include "OperationSub.h"


class OperationFactory
{
public:
	static Operation* createOperation(char sOperate);
};

Operation* OperationFactory::createOperation(char sOperate)
{
	Operation* oper = nullptr;
	switch (sOperate)
	{
	case '+':
		oper = new OperationAdd();
		break;
	case '-':
		oper = new OperationSub();
		break;
	case '*':
		oper = new OperationMul();
		break;
	case '/':
		oper = new OperationDiv();
		break;
	default:
		break;
	}
	return oper;
}
           

4.2.2 四则运算符继承体系代码

1、Operation.h

#pragma once
#include <iostream>

class Operation
{
public:
	Operation() {}
	virtual ~Operation() {}
	virtual double getResult() = 0;
	double getNumberA() { return m_numberA; }
	double getNumberB() { return m_numberB; }
	void setNumberA(const double& num) { m_numberA = num; }
	void setNumberB(const double& num) { m_numberB = num; }
protected:
	double m_numberA{ 0 };
	double m_numberB{ 0 };
};
           

2、OperationAdd.h

#pragma once
#include "Operation.h"
class OperationAdd :
	public Operation
{
public:
	OperationAdd() {}
	virtual ~OperationAdd() {}
	double getResult() override { return m_numberA + m_numberB; }
};
           

3、OperationSub.h

#pragma once
#include "Operation.h"
class OperationSub :
	public Operation
{
public:
	OperationSub() {}
	virtual ~OperationSub() {}
	double getResult() override { return m_numberA - m_numberB; }
};


           

4、OperationMul.h

#pragma once
#include "Operation.h"
class OperationMul :
	public Operation
{
public:
	OperationMul() {}
	virtual ~OperationMul() {}
	double getResult() override { return m_numberA * m_numberB; }
};
           

5、OperationDiv.h

#pragma once
#include "Operation.h"

class OperationDiv :
	public Operation
{
public:
	OperationDiv() {}
	virtual ~OperationDiv() {}
	double getResult() override 
	{
		double result = 0;
		if (m_numberB == 0)
			throw new std::exception("除数不能为0。");
		result = m_numberA / m_numberB;
		return result;
	}
};


           

此为《大话设计模式》学习心得系列 P9~~

简单工厂进阶一：《大话设计模式》C++实现：08 工厂模式

简单工厂进阶二：《大话设计模式》C++实现：01 简单工厂模式（优化，使用宏注册工厂）