看实现代码是理解设计模式的最好途径:
product.h:
#ifndef _PRODUCT_H_
#define _PRODUCT_H_
class Product{
protected:
Product();
public:
virtual ~Product();
};
class ConcreteProduct:public Product{
public:
ConcreteProduct();
~ConcreteProduct();
};
#endif
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();
};
class ConcreateFactory:public Factory{
public:
~ConcreateFactory();
ConcreateFactory();
Product* CreateProduct();
};
#endif
factory.cpp:
#include "factory.h"
#include "product.h"
#include <iostream>
using namespace std;
Factory::Factory(){
}
Factory::~Factory(){
}
ConcreateFactory::ConcreateFactory(){
cout<<"ConcreateFactory..."<<endl;
}
ConcreateFactory::~ConcreateFactory(){
}
Product* ConcreateFactory::CreateProduct(){
return new ConcreteProduct();
}
main.cpp:
#include "factory.h"
#include "product.h"
#include <iostream>
using namespace std;
int main(){
Factory *fac=new ConcreateFactory();
Product*p=fac->CreateProduct();
return 1;
}
我们可以直接从main函数中看出Factory模式的端倪,Factory模式提供了两个功能:
一、提供创建对象的接口封装,
二、将类的实例化推迟到子类
但同时也带来至少两个问题:
一、如果为每一个具体的ConcreteProduct类的实例化提供一个函数体,那么我们不得不在系统中添加一个方法来处理这个新建的ConcreteProduct,这样Factory的接口永远就不可能封闭,不过这个问题是可以通过给Factory传递参数来决定创建哪个具体的Product来解决的
二、Factory模式局限于一类类,即系统中只有Product这一类,如果要为不同类的类提供一个对象创建接口,就要用到AbstractFactory了。