工厂方法--创建型模式（Factory method）

作用：

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

UML结构图：

抽象基类：

    1）Product：创建出来的对象的抽象基类。

    2）Factory创建对象的工厂方法的抽象基类。

    接口函数：

    1）Factory：：createProduct()：纯虚函数，由派生类实现，创建出对应的Product.

    解析：

    在这个模式中，有两个抽象基类，一个是Product为创建出来的对象的抽象基类，一个是Factory是工厂的抽象基类，在互相协作的时候都是由相应的Factory派生类来生成Product的派生类，也就是说如果要新增一种Product那么也要对应的新增一个Factory，创建的过程委托给了这个Factory.也就是说一个Factory和一个Product是一一对应的关系。

代码：

代码片断 1：Product.h
//Product.h
#ifndef _PRODUCT_H_
#define _PRODUCT_H_
class Product{
    public:
    virtual ~Product() =0;
    protected:
    Product(); //屏蔽构造函数
    private:
};
class ConcreteProduct:publicProduct{
    public:
    ~ConcreteProduct();
    ConcreteProduct();
    protected:
    private:
};
#endif //~_PRODUCT_H_

代码片断 2：Product.cpp
//Product.cpp
#include "Product.h"
#include<iostream>
using namespace std;
Product::Product(){
}
Product::~Product(){
}
ConcreteProduct::ConcreteProduct(){
    cout<<"ConcreteProduct...."<<endl;
}
ConcreteProduct::~ConcreteProduct(){
}

代码片断 3：Factory.h
//Factory.h
#ifndef _FACTORY_H_
#define _FACTORY_H_
class Product;
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
//Factory.cpp
#include "Factory.h"
#include "Product.h"
#include <iostream>
using namespace std;
Factory::Factory(){
}
Factory::~Factory(){
}
ConcreteFactory::ConcreteFactory(){
    cout<<"ConcreteFactory....."<<endl;
}
ConcreteFactory::~ConcreteFactory(){
}
Product* ConcreteFactory::CreateProduct(){
    return new ConcreteProduct();
}

代码片断 5：main.cpp
//main.cpp
#include "Factory.h"
#include "Product.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[]){
    Factory* fac = new ConcreteFactory();
    Product* p = fac->CreateProduct();
    return 0;
}