设计模式 --> （1）工厂模式

工厂模式

　　工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。

适用性：

　　例如部署多种数据库的情况，可能在不同的地方要使用不同的数据库，此时只需要在配置文件中设定数据库的类型，每次再根据类型生成实例，这样，不管下 面的数据库类型怎么变化，在客户端看来都是只有一个AbstractProduct，使用的时候根本无需修改代码。提供的类型也可以用比较便于识别的字符 串，这样不用记很长的类名，还可以保存为配置文件。

　　这样，每次只需要修改配置文件和添加新的产品子类即可。

　　所以简单工厂模式一般应用于多种同类型类的情况，将这些类隐藏起来，再提供统一的接口，便于维护和修改。

优点：

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

　　2.客户端基本不用关心使用的是哪个产品，只需要知道用哪个工厂就行了，提供的类型也可以用比较便于识别的字符串。

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

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

缺点：

　　1.要求产品子类的类型差不多，使用的方法名都相同，如果类比较多，而所有的类又必须要添加一种方法，则会是非常麻烦的事情。或者是一种类另一种类有几种方法不相同，客户端无法知道是哪一个产品子类，也就无法调用这几个不相同的方法。

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

简单工厂模式

　　简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。

例如：有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器核，一定要显示地告诉生产工厂。下面给出一种实现方案。

// 简单工厂模式
#include <iostream>
using namespace std;

enum CTYPE {PRODUCT_A, PRODUCT_B}; // 抽象产品
class AbstractProduct
{
public:
    virtual void getProductsName() = 0;
};

// 具体产品1
class ConcreteProduct1: public AbstractProduct
{
public:
    void  getProductsName()  { cout << "ConcreteProduct1" << endl; }
};

// 具体产品2
class ConcreteProduct2: public AbstractProduct
{
public:
    void  getProductsName()  { cout << "ConcreteProduct2" << endl; }
};

// 具体的工厂（没有抽象工厂）,，可以生产两种产品，在内部判断 
class ConcreteFactory
{
public:
    AbstractProduct* getProductObject(enum CTYPE ctype)
    {
        if(ctype == PRODUCT_A)
        {
            return new ConcreteProduct1();
        }
        else if(ctype == PRODUCT_B)
        {
            return new ConcreteProduct2();
        }
        else
        {
            return 0;
        }
    }
};

int main()
{
    ConcreteFactory f;
    AbstractProduct* p1 = f.getProductObject(PRODUCT_A);
    AbstractProduct* p2 = f.getProductObject(PRODUCT_B);
    p1->getProductsName();
    p2->getProductsName();
    delete p1;
    delete p2;
    return 0;
}

这样设计的主要缺点就是要增加新的产品时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。

工厂方法模式

　　工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而 原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的 处理器核了。下面给出一个实现方案。

#include <iostream>
using namespace std;

//普通工厂模式

//抽象产品
class AbstractProduct
{
public:
    virtual void getProductName() = 0;
};

//具体产品1
class ConcreteProduct1: public AbstractProduct
{
public:
    void getProductName() { cout << "ConcreteProduct1" << endl; }
};

//具体产品2
class ConcreteProduct2: public AbstractProduct
{
public:
    void getProductName() { cout << "ConcreteProduct2" << endl; }
};

//抽象工厂
class AbstractFactory
{
public:
    virtual AbstractProduct* getProduct() = 0;
};

//具体工厂1
class ConcreteFactory1: public AbstractFactory
{
public:
    AbstractProduct* getProduct()
    {
        return new ConcreteProduct1();
    }
};

//具体工厂2
class ConcreteFactory2: public AbstractFactory
{
public:
    AbstractProduct* getProduct()
    {
        return new ConcreteProduct2();
    }
};

int main()
{
    AbstractFactory* f1 = new ConcreteFactory1();
    AbstractFactory* f2 = new ConcreteFactory2();
    f1->getProduct()->getProductName();
    f2->getProduct()->getProductName();
    delete f1, f2;
    return 0;
}

工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的产品，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。

抽象工厂模式

　　抽象工厂模式，为提供一个创建一系列相关或相互依赖对象的接口，而需指定它们具体的类。

这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，下面给出实现的代码。

#include <iostream>
using namespace std;

// 抽象工厂模式 

// 抽象产品A
class AbstractProductA
{
public:
    virtual void getProductName() = 0;
};

// 具体产品A1
class ConcreteProductA1: public AbstractProductA
{
public:
    void getProductName() { cout << "ConcreteProductA1" << endl; }
};

// 具体产品A2
class ConcreteProductA2: public AbstractProductA
{
public:
    void getProductName() { cout << "ConcreteProductA2" << endl; }
};

// 抽象产品B
class AbstractProductB
{
public:
    virtual void getProductName() = 0;
};

// 具体产品B1
class ConcreteProductB1: public AbstractProductB
{
public:
    void getProductName() { cout << "ConcreteProductB1" << endl; }
};

// 具体产品B2
class ConcreteProductB2: public AbstractProductB
{
public:
    void getProductName() { cout << "ConcreteProductB2" << endl; }
};

// 抽象工厂
class AbstractFactory
{
public:
    virtual AbstractProductA* getProductA() = 0;
    virtual AbstractProductB* getProductB() = 0;
};

// 具体工厂1
class ConcreteFactory1: public AbstractFactory
{
    AbstractProductA* getProductA()
    {
        return new ConcreteProductA1;
    }

    AbstractProductB* getProductB()
    {
        return new ConcreteProductB1;
    }
};
 
// 具体工厂2
class ConcreteFactory2: public AbstractFactory
{
    AbstractProductA* getProductA()
    {
        return new ConcreteProductA2;
    }

    AbstractProductB* getProductB()
    {
        return new ConcreteProductB2;
    }
};

int main()
{
    AbstractFactory *f1 = new ConcreteFactory1();
    AbstractFactory *f2 = new ConcreteFactory2();
    f1->getProductA()->getProductName();
    f1->getProductB()->getProductName();
    f2->getProductA()->getProductName();
    f2->getProductB()->getProductName();
    delete f1, f2;
    return 0;
}

至此，三种模式介绍完毕。

参考：http://blog.csdn.net/wuzhekai1985