工厂模式分三类：

• 简单工厂
• 工厂方法
• 抽象工厂

简单工厂不属于设计模式，因为其违背了设计模式的开闭原则，后面会有介绍。

工厂方法

factory_function.png

相关元素：

• 抽象工厂
• 具体工厂
• 抽象产品
• 具体产品

示例

抽象产品

class Car {
public:
    virtual void printInfo()=0;
};

具体产品

class BenChi :public Car {
public:
    void printInfo() {
        cout << "BenChi" << endl;
    }
};

class Aodi :public Car {
public:
    void printInfo() {
        cout << "Aodi" << endl;
    }
};

抽象工厂

class AbstractFactory {
public:
    virtual Car * createCar() = 0;
};

具体工厂：

class FactoryBenchi :public AbstractFactory {
public:
    Car * createCar() {
        return new BenChi();
    };
};

class FactoryAodi :public AbstractFactory {
public:
    Car * createCar() {
        return new Aodi();
    };
};

这是一个比较标准的工厂方法设计模式。车可以生产车，那具体的奥迪车工厂可以生产奥迪车，奔驰车工厂可以生产奔驰的车。当需要生产法拉利的车时，我们只需要实现一个法拉利的产品，然后实现一个法拉利的工厂即可，而不需要修改之前的代码。这符合开闭原则。

简单工厂

factory_simple.png

这是工厂模式的简单实现方式，包含元素

• 工厂类
• 抽象产品
• 抽象方法

示例

这里抽象产品和抽象方法和前面一样。
工厂类

class SimpleFactory{
public:
    static Car * createCar(const string type) {
        if (type == string("benchi")) {
            return new BenChi();
        }
        else if (type == string("aodi")) {
            return new Aodi();
        }
        else {
            return NULL;
        }
    }
};

我们看到工厂类就是一个单独的类，通过传入的参数来区分返回什么样的产品。比如：当需要生产法拉利时，我们需要修改工厂类的方法。这不符合开闭原则，所以它不属于设计模式。只是工厂模式的一个变相简单的实现。

抽象工厂

前面说到工厂方法只能生产一个类型的产品。当我们需要生产一系列的产品，比如：我们需要奥迪的发动机，那么肯定也是在奥迪的工厂生产，那么这里就可以使用抽象工厂设计模式

元素

• 抽象工厂
• 具体工厂
• 抽象产品（多个）
• 具体产品

示例

这里我们再Car的基础上在增加一个产品Engine

class Engine {
public:
    virtual void printName() = 0;
};

实现类：

class EngineBenchi :public Engine {
public:
    void printName() {
        cout << "benchi engine" << endl;
    }
};

class EngineAodi :public Engine {
public:
    void printName() {
        cout << "aodi engine" << endl;
    }
};

抽象类也需要进行修改：

class AbstractFactory {
public:
    virtual Car * createCar() = 0;
    virtual Engine * createEngine() = 0;
};

实现类：

class FactoryBenchi :public AbstractFactory {
public:
    Car * createCar() {
        return new BenChi();
    };
    Engine * createEngine() {
        return new EngineBenchi();
    }
};

class FactoryAodi :public AbstractFactory {
public:
    Car * createCar() {
        return new Aodi();
    };
    Engine * createEngine() {
        return new EngineAodi();
    }
};

测试代码：

int main()
{
    AbstractFactory *factory = NULL;
    Car* car = NULL;
    Engine* engine = NULL;
    factory=new FactoryBenchi();
    car = factory->createCar();
    car->printInfo();
    engine = factory->createEngine();
    engine->printName();
    delete factory;
    delete car;
    delete engine;
    factory = new FactoryAodi();
    car = factory->createCar();
    car->printInfo();
    engine = factory->createEngine();
    engine->printName();
    delete factory;
    delete car;
    delete engine;
    return 0;
}

这样我们就完成的奥迪工厂既可以生产车，也可以生产发动机。同样我们也发现了他的缺点。当需要再添加一种商品时，发现需要修改很多地方。抽象工厂需要修改，同时所有的实现类都需要发生修改。产品的扩展很复杂。优点当然也明显，它是的产品族的多个产品设计在一起工作时，它能保证使用的是同一个产品族的产品。