简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端(使用工厂类)的选择条件动态实例化相关的类,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖。对于动态实例化,我们可以借助智能指针来完成对对象的管理。
代码如下:
#include <iostream>
#include <memory>
using namespace std;
/* 简单工厂模式
* 一个虚基类,若干子类继承该类,同时实现对应的虚函数实现
* 在需要生成子类的时候,向工厂中传入对应的标志,动态生成对应的子类,以虚基类的指针
* 来接受new出子类的地址
*/
//子类的共同父类
class COperator
{
public:
virtual double GetResult() = 0;
virtual ~COperator() {};
COperator() :
m_dNumberA(0),m_dNumberB(0){}
double GetNumberA() const { return m_dNumberA; }
void SetNumberA(double numberA) { m_dNumberA = numberA; }
double GetNumberB() const { return m_dNumberB; }
void SetNumberB(double numberA) { m_dNumberB = numberA; }
protected:
double m_dNumberA;
double m_dNumberB;
};
//加法子类
class CPlusOperator : public COperator
{
public:
virtual double GetResult() { return m_dNumberA + m_dNumberB; }
};
//减法子类
class CSubOperator : public COperator
{
~CSubOperator() { cout << "对象被删除" << endl; }
public:
virtual double GetResult() { return m_dNumberA - m_dNumberB; }
};
typedef enum tag_Opeartor {
AddOperator = 1,
SubOperator = 2,
Operator_max
}OPEARTOR_E;
//工厂类
class COperatorFactory
{
public:
COperatorFactory() {};
~COperatorFactory() = default;
static COperator* CreatorOperator(const OPEARTOR_E & val )
{
COperator* pOperator = nullptr;
switch (val)
{
case AddOperator:
pOperator = new(std::nothrow) CPlusOperator();
break;
case SubOperator:
pOperator = new(std::nothrow) CSubOperator();
break;
default:
cout <<" val is error!val is" << val << '.' << endl;
break;
}
return pOperator;
}
};
int main()
{
//std::shared_ptr<COperator> op(COperatorFactory::CreatorOperator(AddOperator));
std::shared_ptr<COperator> op(COperatorFactory::CreatorOperator(SubOperator));
op->SetNumberA(20);
op->SetNumberB(30);
cout << op->GetResult() << endl;
return 0;
}