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

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;
}