工厂方法模式

工厂方法模式
该模式又简称为工厂模式，定义一个用于创建对象的接口，让子类决定让哪一个类实例化，这样可以让产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该确定实例化哪一个具体产品类。

Product 抽象产品，是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类。
ConcreteProduct 具体产品，实现了抽象产品的接口，某种类型的具体产品有专门的具体工厂负责创建，具体工厂和具体产品之间意义对应。
Factory 抽象工厂，在抽象工厂类中声明了工厂方法，用于返回一个产品，抽象工厂是工厂方法模式的核心，所有创建对象的工厂类都必须实现该接口。
ConcreteFactory 具体工厂，是具体工厂的子类，实现了抽象工厂中定义的工厂方法，并可以由客户端调用返回一个具体的产品子类。

C++实现的工厂方法模式
AbstractFactory.h

#include <stdio.h>
#include "AbstractProduct.h"

class AbstractFactory
{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
    virtual AbstractProduct * createProduct() = 0;
};

class FactoryA:public AbstractFactory
{
public:
    FactoryA();
    ~FactoryA();
    AbstractProduct * createProduct();
};

class FactoryB:public AbstractFactory
{
public:
    FactoryB();
    ~FactoryB();
    AbstractProduct * createProduct();
};

AbstractFactory.cpp

#include "AbstractFactory.h"


AbstractFactory::AbstractFactory(){}

AbstractFactory::~AbstractFactory(){}

FactoryA::FactoryA(){}

FactoryA::~FactoryA(){}

AbstractProduct * FactoryA::createProduct()
{
    AbstractProduct * temp = NULL;
    temp = new ProductA();
    return temp;
}

FactoryB::FactoryB(){}

FactoryB::~FactoryB(){}

AbstractProduct * FactoryB::createProduct()
{
    AbstractProduct * temp = NULL;
    temp = new ProductB();
    return temp;
}

AbstractProduct.h

#include <stdio.h>


class AbstractProduct
{
public:
    AbstractProduct();
    virtual ~AbstractProduct();
    virtual void operation() = 0;
};

class ProductA:public AbstractProduct
{
public:
    ProductA();
    virtual ~ProductA();
    void operation();
};

class ProductB:public AbstractProduct
{
public:
    ProductB();
    ~ProductB();
    void operation();
};

AbstractProduct.cpp

#include "AbstractProduct.h"


AbstractProduct::AbstractProduct(){}

AbstractProduct::~AbstractProduct(){}

ProductA::ProductA(){}

ProductA::~ProductA(){}

void ProductA::operation()
{
    printf("hello ProductA\n");
}

ProductB::ProductB(){}

ProductB::~ProductB(){}

void ProductB::operation()
{
    printf("hello ProductB\n");
}

client.cpp

#include "AbstractFactory.h"

int main()
{
    AbstractFactory * f_a = new FactoryA();
    AbstractProduct * p_a = f_a->createProduct();
    p_a->operation();
    delete p_a;
    p_a = NULL;
    delete f_a;
    f_a = NULL;

    AbstractFactory * f_b = new FactoryB();
    AbstractProduct * p_b = f_b->createProduct();
    p_b->operation();
    delete(p_b);
    p_b = NULL;
    delete(f_b);
    f_b = NULL;
    system("pause");
}

特点：
优缺点和简单工厂模式差不多。主要区别如下：
可以看出工厂模式就是改进了简单工厂模式中的开放-封闭原则。在简单工厂模式中每增加一个产品的时候就需要修改条件分支增加一个判断，违背了开放-封闭原则。而工厂模式每次添加产品子类的时候，只需再添加一个工厂子类就可以了。

由于在该模式中每个工厂类只生产一类产品，可能会导致系统中在大量的工厂类，因此考虑相关产品形成一个产品簇，由同一类工厂来实现，这就是抽象工厂模式，见下一篇。