前言
在面向对象系统设计中经常可以遇到以下的两类问题：
1）为了提高内聚（Cohesion）和松耦合（Coupling），我们通常会抽象出类的公共接口以形成抽象基类或者接口。基于此，我们可以通过定义一个指向基类的指针来指向实际的子类实现，达到了多态的目的。但是，当有许多的子类继承自抽象基类，我们每次要用到子类式就需要重新定义子类，诸如 new ×××的代码。这样处理会带来两个问题 ：1.客户程序员必须知道实际子类的名称（当系统复杂后，命名可能就出现了问题）；2.程序的扩展性和维护变得越来越困难。
2）在父类中并不知道具体要实例化哪一个具体的子类。诸如：假设我们在类 A 中要使用到类 B，B 是一个抽象父类，在 A 中并不知道具体要实例化那一个 B 的子类，但是在类 A 的子类 D 中是可以知道的。因此，在 A 中我们没有办法直接使用类似于 new ×××的语句，因为我们就不知道要定义哪个具体的子类。
以上两个问题也就引出了 Factory 模式的两个最重要的功能：
1）定义创建对象的接口，封装了对象的创建；
2）使得具体化类的工作延迟到了子类中。
一、工厂模式(Factory 模式)
我们通常使用 Factory 模式来解决上面两个问题。对于第一个问题，我们声明一个创建对象的接口，并封装了对象的创建过程。Factory 这里类似于一个真正意义上的工厂（生产对象）。对于第二个问题，需提供一个对象创建对象的接口，并在子类中提供其具体实现（因为只有在子类中可以决定到底实例化哪一个类）。下面给出了 Factory 模式对应的UML图：
二、具体源码
1.Product.h
代码如下（示例）：
#pragma once
#ifndef _PRODUCT_H_
#define _PRODUCT_H_
#include <iostream>
//纯虚函数，定义接口
class Product
{
public:
virtual ~Product() = 0;
protected:
Product();
private:
};
//子类中具体实现相关功能
class ConcreteProduct :public Product
{
public:
~ConcreteProduct();
ConcreteProduct();
protected:
private:
};
#endif //PRODUCT_H
2.Product.cpp
代码如下（示例）：
#include "Product.h"
Product::Product()
{
}
Product::~Product()
{
}
ConcreteProduct::ConcreteProduct()
{
std::cout << "ConcreteProduct...." << std::endl;
}
ConcreteProduct::~ConcreteProduct()
{
}
3.Factory.h
代码如下（示例）：
#pragma once
#ifndef _FACTORY_H_
#define _FACTORY_H_
#include"Product.h"
//工厂抽象类，定义接口CreateProduct，无法实例化
class Factory
{
public:
virtual ~Factory() = 0;
virtual Product* CreateProduct() = 0;
protected:
Factory();
private:
};
//工厂子类，实现具体功能：创造相应的产品类
class ConcreteFactory :public Factory
{
public:
~ConcreteFactory();
ConcreteFactory();
//创造产品子类的具体实例，返回产品父类的指针
Product* CreateProduct(); protected:
private:
};
#endif //FACTORY_H
4.Factory.cpp
代码如下（示例）：
#include "Factory.h"
Factory::Factory()
{
}
Factory::~Factory()
{
}
ConcreteFactory::ConcreteFactory()
{
std::cout << "ConcreteFactory....." << std::endl;
}
ConcreteFactory::~ConcreteFactory()
{
}
Product* ConcreteFactory::CreateProduct()
{
//创建具体产品子类示例的智能指针，防止内存被消除
std::shared_ptr<ConcreteProduct> ptr = std::make_shared<ConcreteProduct>();
//将子类指针转化为父类指针
return dynamic_cast<Product*>(ptr.get());
}
5.main.cpp
代码如下（示例）：
#include "Factory.h"
#include "Product.h"
int main(int argc, char* argv[])
{
Factory* fac = new ConcreteFactory();
Product* p = fac->CreateProduct();
return 0;
}
三、运行结果
结果如下：
总结
Factory 模式在实际开发中应用非常广泛，面向对象的系统经常面临着对象创建问题：要创建的类实在是太多了。而 Factory 提供的创建对象的接口封装（第一个功能），以及其将类的实例化推迟到子类（第二个功能）都部分地解决了实际问题。但是如果每新添一个具体的 ConcreteProduct 类，那么我们必须在系统中添加了一个工厂来处理这个新建的ConcreteProduct。在实现中我们可以通过参数化工厂方法，即给 FactoryMethod（）传递一个参数用以决定是创建具体哪一个具体的 Product。当然也可以通过模板化避免这个问题，其方法就是将具体 Product 类作为模板参数，实现起来也很简单。这些实现细节需要我们遇到具体问题具体分析。
本文参考《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》，对内容进行整理，方便大家学习。如想学习详细内容，请参考此书。
