工厂模式

问题：

在面向对象系统中经常可以遇到以下的两类问题：

1）为了提高内聚（Cohesion）和松耦合（Coupling）,我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。这里很容易出现的一个问题n多的子类继承自抽象基类，我们不得不在每次要用到子类的地方编写如 new xxx;的代码

带来两个问题：

a) 客户程序员必须千知道实际子类的名称（当系统复杂后，命名将是一个很不好处理的问题）

b) 程序的扩展性和维护变量越来越困难。

2）还有一种情况是在父类中并不知道具体要实例化哪一个具体的子类。

假设我们在类A中要使用到类B，B是一个抽象父类，在A中并不知道具体要实例化哪一个B的子类，但是在A的子类D中是可以知道的。

Factory模式的两个最重要的功能：

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

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

模式选择：

第一种情况的FActory结构示意图：

第二种情况的Factory结构示意图：

实现：

#ifndef _PRODUCT_H_

#define _PRODUCT_H_

#include <iostream>

#include <string>

using namespace std;

class Product{

public:

Product();

virtual ~Product();

string ProductName()

{

return m_prtName;

}

protected:

string m_prtName;

};

class OneProduct:public Product

{

public:

OneProduct();

virtual ~OneProduct();

};

class TwoProduct:public Product

{

public:

TwoProduct();

virtual ~TwoProduct();

};

#endif // _PRODUCT_H_

#ifndef _FACTORY_H_

#define _FACTORY_H_

#include<iostream>

#include<string>

#include "Product.h"

using namespace std;

class Product;

class Factory{

public:

Factory();

virtual ~Factory();

Product* FactoryMethod(string& type);

virtual Product* CreateProduct(string&type)=0;

};

class OneFactory:public Factory

{

public:

OneFactory();

virtual ~OneFactory();

Product* CreateProduct(string& type);

};

#endif //_FACTORY_H_

#include "Product.h"

using namespace std;

Product::Product()

{

m_prtName = "Product";

}

Product:: ~Product()

{

}

OneProduct::OneProduct()

{

m_prtName="One Product ";

}

OneProduct:: ~OneProduct()

{

}

TwoProduct::TwoProduct()

{

m_prtName = "Two Product ";

}

TwoProduct::~TwoProduct()

{

}

#include "Factory.h"

#include "Product.h"

Factory::Factory()

{

}

Factory:: ~Factory()

{

}

Product* Factory::FactoryMethod(string& type)

{

Product* product = CreateProduct(type);

return product;

}

OneFactory::OneFactory()

{

cout<<"One Factory" <<endl;

}

OneFactory::~OneFactory()

{

}

Product* OneFactory::CreateProduct(string& type)

{

if (strcmp(type.c_str(),"one")==0)

{

return new OneProduct();

}

else if (strcmp(type.c_str(),"two")==0)

{

return new TwoProduct();

}

else {

return NULL;

}

}

#include <iostream>

#include <string>

#include "Factory.h"

#include "Product.h"

using namespace std;

int main()

{

Factory* fact = new OneFactory();

Product* pd = fact->CreateProduct(string("one"));

cout<<pd->ProductName()<<endl;

delete pd;

pd = fact->CreateProduct(string("two"));

cout<<pd->ProductName()<<endl;

delete pd;

delete fact;

cin.get();

return 0;

}