Factory模式

　　Factory模式的两个重要功能：

1）定义创建对象的接口，封装了对象的创建；

2）使得具体化类的工作延迟到了子类中。

　　声明一个创建对象的接口，并封装了对象的创建过程的Factory的结构示意图为：

　　Factory模式不单是提供了创建对象的接口，其最重要的是延迟了子类的实例化。

　　　　　　　　　　　　　　　　　　图二

　　图二中Factory模式的应用并不是只是为了封装对象的创建，而是要把对象的创建放到子类中实现：Factory中只是提供了对象创建的接口，其实现将放在Factory的子类ConcreteFactory中进行。这是图二和图一的区别所在。

完整代码示例：

//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_ 

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

//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_ 

//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(); 
} 

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

　示例代码中给出的是Factory模式解决父类中并不知道具体要实例化哪一个具体的子类的问题，至于为创建对象提供接口问题，可以由Factory中附加相应的创建操作例如Create***Product（）即可。