工厂模式

定义：一个用于从一组派生类中创建一个类的实例的实用程序类

抽象工厂：一个创建几个类的实例的实用程序类。也可以返回某一组的工厂类。

工厂设计模式在需要创建多种不同类型的对象，所有派生类来自于相同的基类有比较大的用处。工厂方法定义了一个创建对象的方法，子类可以重写以指定将要创建的派生类类型。因此，在运行时，工厂方法可以传递一个期待对象的描述。并且给新的实例返回基类指针。当为基类使用精心设计的接口时，该模式效果最佳，因此不需要投射返回的对象。

问题：我们想在运行时根据配置或运行参数确定创建哪一种类型的对象。当我们写代码时，不确定应该创建哪种类型的对象。

解决方案：定义一个创建对象的接口，但是，由子类决定实例化哪种对象。工厂方法将一个类的实例化推迟到子类。

#include <iostream>
using namespace std;
 class Computer
 {
 public:
     virtual void Run() = 0;
     virtual void Stop() = 0;
     virtual void Display() = 0;
     virtual ~Computer() {}; /* without this, you do not call Laptop or Desktop destructor in this example! */
 };

  class Laptop: public Computer
 {
 public:
     void Run() override {mHibernating = false;};
     void Stop() override {mHibernating = true;};
     void Display() {cout<<"The Laptop"<<mHibernating<<endl;};
     virtual ~Laptop() {}; /* because we have virtual functions, we need virtual destructor */
 private:
     bool mHibernating; // Whether or not the machine is hibernating
 };

 class Desktop: public Computer
 {
 public:
     void Run() override {mOn = true;};
     void Stop() override {mOn = false;};
     void Display() {cout<<"The Desktop"<<mOn<<endl;};
     virtual ~Desktop() {};
 private:
     bool mOn; // Whether or not the machine has been turned on
 };


 class ComputerFactory
 {
 public:
     static Computer *NewComputer(const std::string &description)
     {
         if(description == "laptop")
             return new Laptop;
         if(description == "desktop")
             return new Desktop;
         return NULL;
     }
 };


int main()
{
    string computertype("laptop");
    ComputerFactory mycomputerfactory;
    Computer *lap = mycomputerfactory.NewComputer(computertype);
    lap->Run();
    lap->Display();

    computertype = "desktop";
    Computer *desktop = mycomputerfactory.NewComputer(computertype);
    desktop->Run();
    desktop->Display();

    cout << "Hello world!" << endl;
    return 0;
}

让我们分析下这种设计的好处。首先，有一个编译的好处如果我们把接口Computer移动到一个单独的头文件中，可以把NewComputer()函数移动到一个单独的执行文件中。现在实施文件中的NewComputer()是唯一一个需要派生类相关的文件。因此，如果任何一个派生类，或者添加一个新的子类，只需要改变NewComputer（），也只需要编译该执行文件。使用工厂模式，仅仅需要关心接口，保证在整个应用过程中接口的一致性。

如果有需要增加一个类，用户通过一个用户接口请求一个对象，调用工厂模式的代码不需要改变。使用工厂模式的代码将简单传递一个新的字符串，并且允许工厂处理新的类型。

假设编写一个视屏程序游戏，你想在将来可以添加新的敌人类型，这个敌人有新的AI功能和根据不通的情况进行更新。通过使用工厂方法，程序的控制者可以通过工厂模式创建新的敌人，不需要依赖于实际的类型。未来的开发者可以创建有AI控制和新的绘制的敌人。增加该敌人到工厂模式。结合工厂模式和xml文件描述，开发者不需要重新编译他们的程序。所有这些，幸亏把对象的创建从对象的信息中分离了出来。