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

工厂方法模式：定义一个用于创建对象的借口，让子类决定实例化哪一个类。 Factory method使一个类的实例化延迟到子类。

当系统准备为用户提供某个类的子类的实例，又不想让用户代码和孩子类形成耦合时，可以使用工厂方法模式来设计系统。

工厂方法模式的关键在于工厂接口里面有一个抽象方法，在具体工厂中，这个方法返回某个产品的实例。

工厂方法模式中有四个角色：

1、构造者（Factory）

2、具体构造者（Concrete Factory）

3、抽象产品（Product）

4、具体产品（Concrete Product）

在实际的依赖关系中，构造者（工厂）会依赖产品。

本文C++实现的例子中，圆珠笔是用户需要的，而笔芯是具体产品，所以定义了PenCore作为抽象产品，构造者是生产圆珠笔的工厂BallPen，因为有三种具体产品，所以相应的也有三种具体构造者。

总共有5个文件，两个头文件，两个源文件，一个主函数作为测试文件。

1、Factory.h

 #ifndef _FACTORY_H_
 #define _FACTORY_H_
 #include <iostream>
 #include <string>
 #include "Product.h"
 using namespace std;

 class PenCore;

 //抽象工厂-这里是钢笔类
 class BallPen
 {
 public:
     BallPen(){};

     virtual ~BallPen(){}

     virtual PenCore* getPenCore() = ;

 };

 //具体工厂
 class RedBallPen : public BallPen
 {
 public:
     PenCore* getPenCore();
 };

 class BlueBallPen : public BallPen
 {
 public:
     PenCore* getPenCore();
 };

 class BlackBallPen : public BallPen
 {
 public:
     PenCore* getPenCore();
 };

 #endif

2、Factory.cpp

 #include "Factory.h"

 PenCore* RedBallPen::getPenCore()
 {
     PenCore *pen = new RedPenCore();
     return pen;
 }

 PenCore* BlueBallPen::getPenCore()
 {
     PenCore *pen = new BluePenCore();
     return pen;
 }

 PenCore* BlackBallPen::getPenCore()
 {
     PenCore *pen = new BlackPenCore();
     return pen;
 }

3、Product.h

 #ifndef _PRODUCT_H_
 #define _PRODUCT_H_
 #include <iostream>
 #include <string>
 using namespace std;

 //抽象产品类
 class PenCore
 {
 public:
     PenCore(){}

     virtual ~PenCore(){}

     virtual void writeWord(string s) = ;

 public:
     string color;
 };

 //具体产品类
 class RedPenCore : public PenCore
 {
 public:
     RedPenCore();

     void writeWord(string s);
 };

 class BluePenCore : public PenCore
 {
 public:
     BluePenCore();

     void writeWord(string s);

 };

 class BlackPenCore : public PenCore
 {
 public:
     BlackPenCore();

     void writeWord(string s);

 };
 #endif

4、Product.cpp

 #include "Product.h"

 RedPenCore::RedPenCore()
 {
     color = "Red";
 }

 void RedPenCore::writeWord(string s)
 {
     cout << "write " << color << "  " << s << endl;
 }

 BluePenCore::BluePenCore()
 {
     color = "Blue";
 }

 void BluePenCore::writeWord(string s)
 {
     cout << "write " << color << "  " << s << endl;
 }

 BlackPenCore::BlackPenCore()
 {
     color = "Black";
 }

 void BlackPenCore::writeWord(string s)
 {
     cout << "write " << color << "  " << s << endl;
 }

5、VirtualConstructorTest.cpp

 #include "Factory.h"
 #include "Product.h"

 int main()
 {
     BallPen *ballPen = new BlueBallPen();
     PenCore *pen = ballPen->getPenCore();
     pen->writeWord("hello");
     delete pen;
     pen = NULL;
     delete ballPen;
     ballPen = NULL;

     ballPen = new RedBallPen();
     pen = ballPen->getPenCore();
     pen->writeWord("world");
     delete ballPen;
     ballPen = NULL;
     delete pen;
     pen = NULL;

     return ;
 }

C++中实现要注意的是，首先工厂中的抽象方法返回类型是抽象产品的指针，然后在C++中自己new的对象一定要delete，防止内存泄露。

与java不同的是，在C++中，抽象工厂中的构造函数并不能调用自己另外的纯虚函数，因为这个函数需要子类实现之后才能调用，而在java中确可以。