（二）工厂方法模式-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() = 0;


};

//具体工厂
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) = 0;

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 0;
}

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

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