大话设计模式之简单工厂模式

最新推荐文章于 2023-06-22 14:09:58 发布

GF89

最新推荐文章于 2023-06-22 14:09:58 发布

阅读量399

点赞数 1

CC 4.0 BY-SA版权

分类专栏：设计模式文章标签： C++ 工厂模式

本文链接：https://blog.youkuaiyun.com/zhuangfangwang/article/details/45850983

设计模式专栏收录该内容

0 篇文章

订阅专栏

本文介绍简单工厂模式的概念及其在计算器应用中的实现。通过一个工厂类决定创建哪种产品类实例，如加减乘除等操作。提供了详细的代码示例，包括工厂类及各种操作类的定义。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1，概念简单工厂模式就是通过一个工厂类决定创建出哪一种产品类的实例。顾名思义工厂就是生产东西的，有原料（参数），模子（对象）就能生产出很多个具有相同功能的对象啦。例如，要设计一个计算器，有许多计算操作，+,-,*,/等，可以通过设计一个计算器操作类工厂，来生产所需要的操作，这就是简单工厂模式

2，UML

3, 示例

//Operate.h

#pragma once
#include <string>
#include <iostream>
class COperation
{
public:
	COperation(void);
public:
	virtual ~COperation(void);
public:
	virtual double GetResult(const double A, const double B) const = 0;
};

//Operate.cpp

#include "Operation.h"

COperation::COperation(void)
{
}

COperation::~COperation(void)
{
}

<pre name="code" class="plain">

</pre>

//OperationSimpleFactory.h

<span style="font-family: Arial, Helvetica, sans-serif;"> 工厂类 */</span>

#pragma once
#include "OperationAdd.h"
#include "OperationSub.h"
#include "OperationMul.h"
#include "OperationDiv.h"
#include <cassert>
class COperationSimpleFactory
{
public:
	COperationSimpleFactory(void);
public:
	~COperationSimpleFactory(void);
public:
	/* 静态工厂方法 */
	static COperation * CreateOperation(const std::string & model);
};

//OperationSimpleFactory.cpp

#include "OperationSimpleFactory.h"

COperationSimpleFactory::COperationSimpleFactory(void)
{
}

COperationSimpleFactory::~COperationSimpleFactory(void)
{
}

COperation * COperationSimpleFactory::CreateOperation(const std::string & model)
{
	if (model == "+")
	{
		return new COperationAdd();
	}
	else if (model == "-")
	{
		return new COperationSub();
	}
	else if (model == "*")
	{
		return new COperationMul();
	}
	else if (model == "/")
	{
		return new COperationDiv();
	}

	else
	{
		assert(false);
	}
	return NULL;
}

//OperationAdd.h

#pragma once
#include "Operation.h"

class COperationAdd : public COperation
{
public:
	COperationAdd(void);
public:
	virtual ~COperationAdd(void);
public:
	virtual double GetResult(const double A, const double B) const;
};

//OperationAdd.cpp

#include "OperationAdd.h"

COperationAdd::COperationAdd(void)
{
	std::cout << "执行加法" << std::endl;
}

COperationAdd::~COperationAdd(void)
{
}
double COperationAdd::GetResult(const double A, const double B) const
{
	double result = 0;
	result = A + B ;
	return result;
}

//OperationDiv.h

#pragma once
#include "Operation.h"

class COperationDiv : public COperation
{
public:
	COperationDiv(void);
public:
	virtual ~COperationDiv(void);
public:
	virtual double GetResult(const double A, const double B) const;
};

//OperationDiv.cpp

#include "OperationDiv.h"
#include <cassert>
COperationDiv::COperationDiv(void)
{
	std::cout << "执行乘法" << std::endl;
}

COperationDiv::~COperationDiv(void)
{
}
double COperationDiv::GetResult(const double A, const double B) const
{
	double result = 0;
	if(B == 0)
		assert(0);
	result = A / B ;
	return result;
}

//OperationMul.h

#pragma once
#include "Operation.h"

class COperationMul : public COperation
{
public:
	COperationMul(void);
public:
	virtual ~COperationMul(void);
public:
	virtual double GetResult(const double A, const double B) const;
};

//OperationMul.cpp

#include "OperationMul.h"
COperationMul::COperationMul(void)
{
	std::cout << "执行乘法" << std::endl;
}

COperationMul::~COperationMul(void)
{
}
double COperationMul::GetResult(const double A, const double B) const
{
	double result = 0;
	result = A * B ;
	return result;
}

//OperationSub.h

#pragma once
#include "Operation.h"

class COperationSub :public COperation
{
public:
	COperationSub(void);
public:
	virtual ~COperationSub(void);
public:
	virtual double GetResult(const double A, const double B) const;
};

//OperationSub.cpp

#include "OperationSub.h"

COperationSub::COperationSub(void)
{
	std::cout << "执行减法：" << std::endl;
}

COperationSub::~COperationSub(void)
{
}

double COperationSub::GetResult(const double A, const double B) const
{
	double result = 0;
	result = A - B ;
	return result;
}

//main

#include "iostream"
#include "OperationSimpleFactory.h"

int main(int argc,char* argv[])
{
	COperation * operate = NULL;

	std::string modeName = "/";
	operate = COperationSimpleFactory::CreateOperation(modeName);
	std::cout<<operate->GetResult(12,0)<<std::endl;
	delete operate;
	operate = NULL;
	return 0;
}