设计模式——工厂模式

一、简单工厂模式

简单工厂模式是工厂模式中最简单的一种，他可以用比较简单的方式隐藏创建对象的细节，一般只需要告诉工厂类所需要的类型，工厂类就会返回需要的产品类，但客户端看到的只是产品的抽象对象，无需关心到底是返回了哪个子类。客户端唯一需要知道的具体子类就是工厂子类。除了这点，基本是达到了依赖倒转原则的要求。所以简单工厂模式一般应该于程序中大部分地方都只使用其中一种产品。

1、优点

1）隐藏了对象创建的细节，将产品的实例化推迟到子类中实现；

2）客户端基本不用关心使用的是哪个产品，只需要知道用哪个工厂就行了；

3）方便添加新的产品子类，每次只需要修改工厂类传递的类型值就行了。

4）遵循了依赖倒转原则。

2、缺点

1）要求产品子类的类型差不多，使用的方法名都相同，如果类比较多，使用的方法名具有不同，客户端则无法知道是哪一个产品子类，也就无法调用这几个不相同的方法；

2）每添加一个产品子类，都必须在工厂类中添加一个判断分支，这违背了开放-封闭原则。

3、示例

 

class IOperation  
{  
public:  
    IOperation() : m_nNumA(0), m_nNumB(0) {}  
    virtual ~IOperation() {}  
      
    virtual void    SetNum(int nNumA = 0, int nNumB = 0)  
    {  
        m_nNumA = nNumA;  
        m_nNumB = nNumB;  
    }  
    virtual int     CalculateResult() = 0;  
      
protected:  
    int m_nNumA, m_nNumB;  
};  

 

 

 

 

class COperationAdd : public IOperation  
{  
public:  
    int     CalculateResult()  
    {  
        return  m_nNumA + m_nNumB;  
    }  
};  

 

 

 

 

class COperationDec : public IOperation  
{  
public:  
    int     CalculateResult()  
    {  
        return  m_nNumA - m_nNumB;  
    }  
};  

 

 

 

 

class CClassFactory  
{  
public:  
    CClassFactory() {}  
    ~CClassFactory() {}  
      
    IOperation* CreateObject(char cOperation)  
    {  
        IOperation* poCOperation = NULL;  
        switch (cOperation)  
        {  
        case '+':  
            {  
                poCOperation = new COperationAdd();  
                break;  
            }  
        case '-':  
            {  
                poCOperation = new  COperationDec();  
                break;  
            }  
        }
          
        return  poCOperation;  
    }  
};  

 

 

 

 

void    main()  
{  
    CClassFactory   oCClassFactory;  
    IOperation*     poIOperation = NULL;  
  
    poIOperation = oCClassFactory.CreateObject('+');  
      
    if (poIOperation)  
    {  
        poIOperation->SetNum(2, 3);  
        printf("2 + 3 = %d\n", poIOperation->CalculateResult());  
          
        delete poIOperation;  
    }  
}

 

 

 

二、工厂模式

工厂模式基本与简单工厂模式差不多，上面也说了，每次添加一个产品子类都必须在工厂类中添加一个判断分支，这样违背了开放-封闭原则，因此，工厂模式就是为了解决这个问题而产生的。

既然每次都要判断，那就把这些判断都生成一个工厂子类，这样，每次添加产品子类的时候，只需再添加一个工厂子类就可以了。这样就完美的遵循了开放-封闭原则。但这其实也有问题，如果产品数量足够多，要维护的量就会增加，好在一般工厂子类只用来生成产品类，只要产品子类的名称不发生变化，那么基本工厂子类就不需要修改，每次只需要修改产品子类就可以了。

1、优点

基本与简单工厂模式一致，多的一点优点就是遵循了开放-封闭原则，使得模式的灵活性更强。

2、缺点

与简单工厂模式类似。

3、示例

保持简单工厂模式的 IOperation 接口和实现对象（COperationAdd 和 COperationDec）

和加减法计算器接口类似，将工厂对象也依赖于抽象接口（和简单工厂模式不同之处）

 

class IOperationFactory  
{  
public:  
    virtual ~IOperationFactory() {}  
      
    virtual IOperation* CreateOperation() = 0;  
};  

 

 

 

 

class COperationFactoryAdd : public    IOperationFactory  
{  
public:  
    IOperation* CreateOperation()  
    {  
        return  new COperationAdd();  
    }  
};  

 

 

 

 

class COperationFactoryDec : public    IOperationFactory  
{  
public:  
    IOperation* CreateOperation()  
    {  
        return  new COperationDec();  
    }  
};  

 

 

 

工厂接口 IOperationFactory 提供一个生产 IOperation 计算对象的接口，然后不同的工厂对象生产不同IOperation 计算对象（加法工厂 COperationFactoryAdd 生产 COperationAdd 对象，减法工厂 COperationFactoryDec 则生产 COperationDec对象），即每一个生产对象对应一个工厂类，一个工厂类只生产一种产品。

 

void    main()  
{  
    IOperationFactory*  pIOperationFactory = new COperationFactoryAdd();    
    IOperation* pIOperation = NULL;  
      
    if (!pIOperationFactory)  
    {  
        return;  
    }  
  
    pIOperation = pIOperationFactory->CreateOperation();  
          
    if (pIOperation)  
    {  
        pIOperation->SetNum(2, 3);  
        printf("2 + 3 = %d\n", pIOperation->CalculateResult());  
          
        delete pIOperation;  
    }  
  
    delete  pIOperationFactory;  
}

 

 

 

三、抽象工厂模式

抽象工厂模式就变得比工厂模式更为复杂，就像上面提到的缺点一样，工厂模式和简单工厂模式要求产品子类必须要是同一类型的，拥有共同的方法，这就限制了产品子类的扩展。于是为了更加方便的扩展，抽象工厂模式就将同一类的产品子类归为一类，让他们继承同一个抽象类，我们可以把他们一起视作一组，然后几组产品构成一族。

1、优点

1）封装了产品的创建。

2）可以支持不同类型的产品，使得模式灵活性更强。

3）可以非常方便的使用一族中间的不同类型的产品。

2、缺点

1）结构太过臃肿，如果产品类型比较多，或者产品族类比较多，就会非常难于管理。

2）每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。

3、示例

Product.h

 

#ifndef _PRODUCT_H_
#define _PRODUCT_H_
 
// 抽象基类AbstractProductA，代表A类产品的抽象
class AbstractProductA
{
public:
    virtual ~AbstractProductA()=0;
    virtual void operation()=0;
protected:
    AbstractProductA();//屏蔽构造函数
};
 
// 派生类ProductA1，继承自AbstractProductA，A类产品的一种实现
class ProductA1 : public AbstractProductA
{
public:
    ProductA1();
    virtual void operation();
    virtual ~ProductA1();
};
 
// 派生类ProductA2，继承自AbstractProductA，A类产品的另一种实现
class ProductA2:public AbstractProductA
{
public:
    ProductA2();
    virtual void operation();
    virtual ~ProductA2();
};
 
// 抽象基类AbstractProductB，代表B类产品的抽象
class AbstractProductB
{
public:
    virtual ~AbstractProductB()=0;
    virtual void operation()=0;
protected:
    AbstractProductB();//屏蔽构造函数
};
 
// 派生类ProductB1，继承自AbstractProductB，B类产品的一种实现
class ProductB1:public AbstractProductB
{
public:
    ProductB1();
    virtual void operation();
    virtual ~ProductB1();
};
 
// 派生类ProductB2，继承自AbstractProductB，B类产品的另一种实现
class ProductB2:public AbstractProductB
{
public:
    ProductB2();
    virtual void operation();
    virtual ~ProductB2();
};
 
#endif

 

 

 

Factory.h

 

#ifndef _FACTORY_H_
#define _FACTORY_H_
 
// AbstractFactory，工厂抽象基类，定义生产A类与B类产品的接口
class AbstractProductA;
class AbstractProductB;
class AbstractFactory
{
public:
    virtual ~AbstractFactory()=0;
    virtual AbstractProductA* CreateProductA()=0;
    virtual AbstractProductB* CreateProductB()=0;
protected:
    AbstractFactory();
};
 
// ConcreteFactory1，派生类，继承自AbstractFactory
// 实现继承的接口，生产产品A和B的一种实现
class ConcreteFactory1:public AbstractFactory
{
public:
    ConcreteFactory1();
    ~ConcreteFactory1();
    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};
 
// ConcreteFactory2，派生类，继承自AbstractFactory
// 实现继承的接口，生产产品A和B的另一种实现
class ConcreteFactory2:public AbstractFactory
{
public:
    ConcreteFactory2();
    ~ConcreteFactory2();
    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};
 
#endif

 

 

 

Product.cpp

 

#include "Product.h"
#include <iostream>
 
using namespace std;
 
//AbstractProductA
AbstractProductA::AbstractProductA()
{
    cout << "AbstractProductA..." << endl;
}
 
AbstractProductA::~AbstractProductA()
{
    cout << "~AbstractProductA..." << endl;
}
 
// ProductA1
ProductA1::ProductA1()
{
    cout << "ProductA1..." << endl;
}
 
ProductA1::~ProductA1()
{
    cout << "~ProductA1..." << endl;
}
 
void ProductA1::operation()
{}
 
// ProductA2
ProductA2::ProductA2()
{
    cout << "ProductA2..." << endl;
}
 
ProductA2::~ProductA2()
{
    cout << "~ProductA2..." << endl;
}
 
void ProductA2::operation()
{}
 
// AbstractProductB
AbstractProductB::AbstractProductB()
{
    cout << "AbstractProductB..." << endl;
}
 
AbstractProductB::~AbstractProductB()
{
    cout << "~AbstractProductB..." << endl;
}
 
// ProductB1
ProductB1::ProductB1()
{
    cout << "ProductB1..." << endl;
}
 
ProductB1::~ProductB1()
{
    cout << "~ProductB1..." << endl;
}
 
void ProductB1::operation()
{}
 
// ProductB2
ProductB2::ProductB2()
{
    cout << "ProductB2..." << endl;
}
 
ProductB2::~ProductB2()
{
    cout << "~ProductB2..." << endl;
}
 
void ProductB2::operation()
{}

 

 

 

Factory.cpp

 

#include "Factory.h"
#include "Product.h"
#include <iostream>
 
using namespace std;
 
AbstractFactory::AbstractFactory()
{
    cout << "AbstractFactory..." << endl;
}
 
AbstractFactory::~AbstractFactory()
{
    cout << "~AbstractFactory..." << endl;
}
 
ConcreteFactory1::ConcreteFactory1()
{
    cout << "ConcreteFactory1..." << endl;
}
 
ConcreteFactory1::~ConcreteFactory1()
{
    cout << "~ConcreteFactory1..." << endl;
}
 
AbstractProductA* ConcreteFactory1::CreateProductA()
{
    return new ProductA1();
}
 
AbstractProductB* ConcreteFactory1::CreateProductB()
{
    return new ProductB1();
}
 
ConcreteFactory2::ConcreteFactory2()
{
    cout << "ConcreteFactory2..." << endl;
}
 
ConcreteFactory2::~ConcreteFactory2()
{
    cout << "~ConcreteFactory2..." << endl;
}
 
AbstractProductA* ConcreteFactory2::CreateProductA()
{
    return new ProductA2();
}
 
AbstractProductB* ConcreteFactory2::CreateProductB()
{
    return new ProductB2();
}

 

main.cpp

 

#include <iostream>
#include "Factory.h"
#include "Product.h"

using namespace std;

int main()
{
    AbstractFactory* fa1 = new ConcreteFactory1();
    AbstractProductA* a1 = fa1->CreateProductA();
    AbstractProductB* b1 = fa1->CreateProductB();

    cout << endl;
    AbstractFactory* fa2 = new ConcreteFactory2();
    AbstractProductA* a2 = fa2->CreateProductA();
    AbstractProductB* b2 = fa2->CreateProductB();

    cout << endl;
    delete fa1;
    delete a1;
    delete b1;

    cout << endl;
    delete fa2;
    delete a2;
    delete b2;

    return 0;
}