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（）即可。