云海游鱼的Blog

    今天介绍另一个比较常用的设计模式：工厂模式。工厂模式是指通过声明一个工厂的接口，然后定义该接口的各个实现类来具体实现不同的工厂。这里不打算写这种一般的方式，而只是写一种简单的工厂模式：静态工厂模式。这种模式的扩展性不如一般工厂模式那么好，但对于我们一般的应用已经足够了（而且系统设计的太复杂也不是好事，呵呵），静态工厂在实际中还是很常用的。

    值得说明的是这次没有像一般工厂模式那样采用普通的指针，而是采用之前介绍的shared_ptr，这是因为采用智能指针就不必担心工厂中创建的对象的释放问题，因为智能指针会帮你做好这一切，^_^

       下面是示例代码，代码中每个类按照不同文件进行放置，这样也可以了解工厂模式的一个好处，减小使用者和创建的产品类之间的依赖关系，这会在后面说明。

FileName: product.h

#ifndef _PRODUCT_H_
#define _PRODUCT_H_

class Product{
 public:
  virtual void myFunc()=0;
};

#endif

FileName: product_one.h

#ifndef _PRODUCT_ONE_H_
#define _PRODUCT_ONE_H_

#include "product.h"

class ProductOne:public Product{
 public:
  ProductOne();
  ~ProductOne();
  void myFunc();
};
#endif

FileName: product_one.cpp

#include "product_one.h"
#include <iostream>

using namespace std;

ProductOne::ProductOne(){
 cout<<"product one: i have been builded."<<endl;
}

ProductOne::~ProductOne(){
  cout<<"Product one: i have been destroyed."<<endl;

}
void ProductOne::myFunc(){
 cout<<"product one myFunc done!"<<endl;
}

FileName: product_two.h

#ifndef _PRODUCT_TWO_H_
#define _PRODUCT_TWO_H_

#include "product.h"

class ProductTwo:public Product{
 public:
  ProductTwo();
  ~ProductTwo();
  void myFunc();
};

#endif

FileName: product_two.cpp

#include "product_two.h"
#include <iostream>

using namespace std;

ProductTwo::ProductTwo(){
 cout<<"product two: i have been builded."<<endl;
}

ProductTwo::~ProductTwo(){
  cout<<"Product two: i have been destroyed."<<endl;
}

void ProductTwo::myFunc(){
 cout<<"product two myFunc done!"<<endl;
}

FileName: product_factory.h

#ifndef _PRODUCT_FACTORY_H_
#define _PRODUCT_FACTORY_H_

#include "product.h"
#include <tr1/memory>
#include <string>

class ProductFactory{
 public:
  static  std::tr1::shared_ptr<Product>  createProduct(std::string productDescript);
};

#endif

FileName: product_factory.cpp

#include "product_factory.h"
#include "product_one.h"
#include "product_two.h"

using namespace std;
using namespace std::tr1;

shared_ptr<Product> ProductFactory::createProduct(string productDescription){

 if(productDescription=="one"){
  shared_ptr<Product> productOne(new ProductOne());
  return productOne; 
  //you can also do like below.
  //return shared_ptr<Product> (new ProductOne());
 }
 else if(productDescription=="two"){
  shared_ptr<Product> productTwo(new ProductTwo());
  return productTwo; 
  //you can also do like below.
  //return shared_ptr<Product> (new ProductTwo());
 }
}

FileName: test_factory.cpp

#include "product.h"
#include "product_factory.h"
#include <string>
#include <iostream>
#include <tr1/memory>

using namespace std;
using namespace std::tr1;

int main(){
 cout<<"test 1 start..."<<endl;
 shared_ptr<Product> myProduct=ProductFactory::createProduct("one");

 myProduct->myFunc();

 cout<<endl<<"test 2 start..."<<endl;
 myProduct=ProductFactory::createProduct("two");
 myProduct->myFunc();
 { 
  cout<<endl<<"test 3 start..."<<endl;
  shared_ptr<Product> myProduct2=ProductFactory::createProduct("one");
  myProduct2->myFunc(); 
 }
 cout<<"all test done."<<endl<<endl;;
}

编译然后运行：

# g++ -o test_factory  test_factory.cpp  product_one.cpp  product_two.cpp  product_factory.cpp
# ./test_factory

运行结果如下：

test 1 start...
product one: i have been builded.
product one myFunc done!

test 2 start...
product two: i have been builded.
Product one: i have been destroyed.
product two myFunc done!

test 3 start...
product one: i have been builded.
product one myFunc done!
Product one: i have been destroyed.
all test done.

Product two: i have been destroyed.

    从上面结果可以看出通过使用工厂模式，可以使实例对象的生成由工厂来完成，减小使用者test_factory与实例产品product_one、product_two的依赖，这样也有利于后续程序的维护，即使product_one后来取消了，改动的代码也不会很大。大家看下test_factory.cpp的包含文件可以看出使用者不需要知道实际的产品子类（不直接知道），减小了编译的依赖。

    通过采用shared_ptr智能指针，可以避免使用者忘记释放掉new产生的实例类。这也使得代码更加安全，不容易造成内存泄露，也更容易编写异常安全或异常中立的代码。

   [题外话]也可以看出shared_ptr对于继承派生有很好的支持，^_^