工厂方法模式（C++实现）

（本文章旨在个人回顾知识点）

建议先看一下简单工厂模式，因为我的例子是在简单工厂模式上修改的。

1、详情：

工厂方法模式包含四个角色：

①抽象工厂角色：这是工厂方法模式的核心，她与应用程序无关。是具体工厂角色必须实现的接口或者是必须继承的父类。（本例中的Factory）

②具体工厂类角色：包含和具体业务逻辑相关的代码。由应用程序调用来创建对应的具体产品。（本例中的AddFactory，SubFactory，MulFactory）

 ③抽象产品角色：具体产品类继承的父类或者需实现的接口。（本例中的MyAlgorithm）

④具体产品角色：具体工厂角色所创建的对象实例。(本例中的MyAdd,MySub,MyMul)

2、应用：

工厂方法模式适用情况包括：一个类不知道它所需要的对象的类；一个类通过其子类来指定创建哪个对象；将创建对象的多任务委托给多个子工厂类中的某一个，客户端在使用是可以无须关心是哪一个工厂子类创建产品子类，需要是再动态指定。

3、UML类图：

4、代码实现：

MyAlgorithm.h

扫描二维码关注公众号，回复： 6435067 查看本文章

#pragma once
//算法接口类
class MyAlgorithm
{
public:
    MyAlgorithm();
    ~MyAlgorithm();

public:
    virtual double GetResult(double param1, double param2) = 0;
};

MyAlgorithm.cpp

#include "stdafx.h"
#include "MyAlgorithm.h"


MyAlgorithm::MyAlgorithm()
{
}


MyAlgorithm::~MyAlgorithm()
{
}

MyAdd.h

#pragma once
#include "MyAlgorithm.h"
class MyAdd:public MyAlgorithm
{
public:
    MyAdd();
    ~MyAdd();

public:
    double GetResult(double param1, double param2);
};

MyAdd.cpp

#include "stdafx.h"
#include "MyAdd.h"

MyAdd::MyAdd()
{
}


MyAdd::~MyAdd()
{
}

double MyAdd::GetResult(double param1, double param2)
{
    return param1 + param2;
}

MySub.h

#pragma once
#include "MyAlgorithm.h"
class MySub:public MyAlgorithm
{
public:
    MySub();
    ~MySub();

public:
    double GetResult(double param1, double param2);
};

MySub.cpp

#include "stdafx.h"
#include "MySub.h"


MySub::MySub()
{
}


MySub::~MySub()
{
}

double MySub::GetResult(double param1, double param2)
{
    return param1 - param2;
}

MyMul.h

#pragma once
#include "MyAlgorithm.h"
class MyMul:public MyAlgorithm
{
public:
    MyMul();
    ~MyMul();

public:
    double GetResult(double param1, double param2);
};

MyMul.cpp

#include "stdafx.h"
#include "MyMul.h"


MyMul::MyMul()
{
}


MyMul::~MyMul()
{
}

double MyMul::GetResult(double param1, double param2)
{
    return param1 * param2;
}

Factory.h

#pragma once
#include "MyAlgorithm.h"
class Factory
{
public:
    Factory();
    ~Factory();

public:
    virtual MyAlgorithm* GetAlgorithm() = 0;
};

Factory.cpp

#include "stdafx.h"
#include "Factory.h"


Factory::Factory()
{
}


Factory::~Factory()
{
}

AddFactory.h

#pragma once
#include "Factory.h"
class AddFactory:public Factory
{
public:
    AddFactory();
    ~AddFactory();

public:
    MyAlgorithm* GetAlgorithm();
};

AddFactory.cpp

#include "stdafx.h"
#include "AddFactory.h"
#include "MyAdd.h"


AddFactory::AddFactory()
{
}


AddFactory::~AddFactory()
{
}

MyAlgorithm* AddFactory::GetAlgorithm()
{
    return new MyAdd();
}

SubFactory.h

#pragma once
#include "Factory.h"
class SubFactory: public Factory
{
public:
    SubFactory();
    ~SubFactory();

public:
    MyAlgorithm* GetAlgorithm();
};

SubFactory.cpp

#include "stdafx.h"
#include "SubFactory.h"
#include "MySub.h"


SubFactory::SubFactory()
{
}


SubFactory::~SubFactory()
{
}

MyAlgorithm* SubFactory::GetAlgorithm()
{
    return new MySub();
}

MulFactory.h

#pragma once
#include "Factory.h"
class MulFactory:public Factory
{
public:
    MulFactory();
    ~MulFactory();

public:
    MyAlgorithm* GetAlgorithm();
};

MulFactory.cpp

#include "stdafx.h"
#include "MulFactory.h"
#include "MyMul.h"


MulFactory::MulFactory()
{
}


MulFactory::~MulFactory()
{
}

MyAlgorithm* MulFactory::GetAlgorithm()
{
    return new MyMul();
}

调用代码：

// FactoryMethodMemo.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "MyAlgorithm.h"
#include "AddFactory.h"
#include "SubFactory.h"
#include "MulFactory.h"

#include <iostream>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    MyAlgorithm* pAlgorithmm = NULL;
    Factory* pFactory = new AddFactory();
    pAlgorithmm = pFactory->GetAlgorithm();
    cout << "add:" << pAlgorithmm->GetResult(3.0, 5.0) << endl;
    delete pAlgorithmm;
    pAlgorithmm = NULL;
    delete pFactory;
    pFactory = NULL;

    pFactory = new SubFactory();
    pAlgorithmm = pFactory->GetAlgorithm();
    cout << "sub:" << pAlgorithmm->GetResult(3.0, 5.0) << endl;
    delete pAlgorithmm;
    pAlgorithmm = NULL;
    delete pFactory;
    pFactory = NULL;

    pFactory = new MulFactory();
    pAlgorithmm = pFactory->GetAlgorithm();
    cout << "mul:" << pAlgorithmm->GetResult(3.0, 5.0) << endl;
    delete pAlgorithmm;
    pAlgorithmm = NULL;

    system("pause");
    return 0;
}

输出结果：