C++ 设计模式-工厂方法

定义一个用于创建对象的接口，让子类决定实例化哪一个类， Factory Method使一个类的实例化延迟到其子类。

延迟到子类来选择实现

经典类图:

具体一个示例:

• 如果一个类需要创建某个接口的对象，但是又不知道具体的实现，这种情况可以选用工厂方法模式，把创建对象的工作延退到子类中去实现。
• 如果一个类本身就希望由它的子类来创建所需的对象的时候，应该使用工厂方法模式。

• 可以在不知具体实现的情况下编程
  工厂方法模式可以让你在实现功能的时候，如果需要某个产品对象，只需要使用产品的接口即可，而无需关心具体的实现。选择具体实现的任务延退到子类去完成。
• 更容易扩展对象的新版本
  已有的代码都不会改变，只要新加入一个子类来提供新的工厂方法实现，然后在客户端使用这个新的子类即可。
• 连接平行的类层次
  工厂方法除了创造产品对象外，在连接平行的类层次上也大显身手。比如有一个硬盘的接口, 具体实现有台式机希捷, 笔记本IBM。所以还会各自有着自己的读写硬盘方法。这种情况下使用工厂方法是比较合适的
  

• 具体产品对象和工厂方法的耦合性。
  在工厂方法模式中，工厂方法是需要创建产品对象的，也就是需要选择具体的产品对象，并创建它们的实例，因此具体产品对象和工厂方法是耦合的。

• 工厂方法模式和抽象工厂模式
  这两个模式可以组合使用，具体的放到抽象工厂模式中去讲。
• 工厂方法模式和模板方法模式
  这两个模式外观类似，都有一个抽象类，然后由子类来提供一些实现，但是工厂方法模式的子类专注的是创建产品对象，而模板方法模式的子类专注的是为固定的算法骨架提供某些步骤的实现。
  这两个模式可以组合使用，通常在模板方法模式里面，使用工厂方法来创建模板方法需要的对象。

#include 
using namespace std;

//客户端使用Creator对象

//抽象产品
class Product {
public:
    virtual ~Product(){}
    virtual void Operation() = 0;
};

//具体产品A
class ConcreteProductA : public Product {
public:
    void Operation() override { cout << "ConcreteProductA" << endl; }
};

//具体产品B
class ConcreteProductB : public Product {
public:
    void Operation() override { cout << "ConcreteProductB" << endl; }
};

//抽象工厂
class Creator{
public:
    //一些操作
    void Operator()
    {
        Product* p = this->FactoryMethod();
        if(p != nullptr)
        {
            p->Operation();
            delete p;
        }
    }

    virtual ~Creator(){}

protected:
    //工厂方法
    virtual Product* FactoryMethod() = 0;
};

class ConcreteCreatorA : public Creator {
protected:
    Product* FactoryMethod() override { return new ConcreteProductA(); }
};

class ConcreteCreatorB : public Creator {
protected:
    Product* FactoryMethod() override { return new ConcreteProductB(); }
};

int main() {
    Creator* cA = new ConcreteCreatorA();
    if(cA != nullptr)
    {
        cA->Operator();
        delete cA;
    }

    Creator* cB = new ConcreteCreatorB();
    if(cB != nullptr)
    {
        cB->Operator(); // ConcreteProductB
        delete cB;
    }
    return 0;
}

#include 
using namespace std;

//客户端使用Creator创建出来的对象

//抽象产品
class Product {
public:
    virtual ~Product(){}
    virtual void Operation() = 0;
};

//具体产品A
class ConcreteProductA : public Product {
public:
    void Operation() override { cout << "ConcreteProductA" << endl; }
};

//具体产品B
class ConcreteProductB : public Product {
public:
    void Operation() override { cout << "ConcreteProductB" << endl; }
};

//抽象工厂
class Creator{
public:
    virtual Product* FactoryMethod() = 0;
    virtual ~Creator(){}
};

class ConcreteCreatorA : public Creator {
protected:
    Product* FactoryMethod() override { return new ConcreteProductA(); }
};

class ConcreteCreatorB : public Creator {
protected:
    Product* FactoryMethod() override { return new ConcreteProductB(); }
};

int main() {
    //示例程序不判空了
    Creator* cA = new ConcreteCreatorA();
    Product* pA = cA->FactoryMethod();
    pA->Operation();
    delete cA;
    delete pA;

    Creator* cB = new ConcreteCreatorB();
    Product* pB = cB->FactoryMethod();
    pB->Operation();
    delete cB;
    delete pB;
    return 0;
}