设计模式之工厂模式

设计模式之工厂模式

一.使用的情况

      为了提高内聚和松耦合,我们要经常的抽象出一些公共的借口以形成抽象基类或者接口.我们可以通过声明一个指向基类的指针来指向实际的子类来实现,达到了多态的目的.

 二.重要的功能

   1>定义创建对象的接口,封装了对象的创建.   

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

三.模块分析   

  1>一个n多的子类集成自抽象类,我们就得用new XXX,客户程序员必须直到实际子类的名称,如果系统很复杂,那么就会又冲突的名字  

      命名;程序的扩展性和维护型就变得很差;  

  2>我们不知道父类中具体要实例化哪一个子类.例如:在A类中要使用B类,B类是一个抽象父类,在A中并不知道具体要实例化哪一个B的

      子类,但是在A的子类D中可以知道.

 

四.实现代码

   1>Product.h
   class Product{
     public:
                virtual ~Product()=0;
     protected:
                Product();
  };
  class ConcreteProduct:public Product{
      public:
              ~ConcreteProduct();
               ConcreteProduct();    
  };

  2>Product.cpp
   #include <iostream>
   usingnamespace std;
  
   Product::Product()
   {
   }
   Product::~Product()
   {
   }
   ConcreteProduct::ConcreteProduct()
   {
      cout<<"ConcreteProduct..."<<endl;
   }
   ConcreteProduct::~ConcreteProduct()
   {
   }

  3>Factory.h
   class Product;

   class Factory
   {
    public:
        virtual ~Factory()=0;
        virtual Product* CreateProduct()=0;
    protected:
         Factory();
   } 
   class ConcreteFactory:public Factory
   {  
     public:
         ~ConcreteFactory(); 
         ConcreteFactory(); 
         Product* CreateProduct(); 
  }
  4>Factory.cpp
  #include "Factory.h" 
  #include "Product.h"
  #include <iostream>
  using namespace std;
  Factory::Fatcory()
  {
  }
    
  Factory::~Fatcory()
  {
  }
    
  ConcreteFactoy::ConcreteFactoy()
  {
     cout<<"ConcreteFactory..."<<endl;
  }
    
   ConcreteFactoy::~ConcreteFactoy()
  {
       
  }

   Product* ConcreteFactory::CreateProduct()
   {
      return new ConcreteProduct();
   }

   5>main.cpp

   #include "Factroy"
   #include "Product"
   #include <iostream>
   using namespace std;
   int main(int argc,char* argv[])
   {

      Factory* fac=new ConcreteFatcory(); 

      Product* p=fac->CreateProduct();

      return 0;
   }