开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第1天。

前言

在面向对象系统设计中经常可以遇到以下的两类问题：

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++实现源码》，对内容进行整理，方便大家学习。如想学习详细内容，请参考此书。