【设计模式攻略】创建型模式之Factory模式

class AbstractObject {};

class ConcreteObjectA : public AbstractObject {};
class ConcreteObjectB : public AbstractObject {};
class ConcreteObjectNULL : public AbstractObject {};
    
class Factory {
public:
     AbstractObject* create_object(const string& type) {
          if (type == "A") {
               return new      ConcreteObjectA;
          } else if type == "B") {
               return new      ConcreteObjectB;
          }
          return new ConcreteObjectNULL;
     }
};

class Factory {
public:
     AbstractObject* create_object(const string& type) {
          std::map<string, Factory*>::iterator it;
          it = factory_map.find(type);
          if (it != factory_map.end()) {
               return factory_map[type]->do_create();
          }
          return factory_map["NULL"]->do_create();
     }
    
     void register_factory(const string& type, Factory* factory) {
          factory_map[type] = factory;
     }
private:
     virtual AbstractObject* do_create() = 0;
     static std::map<string, Factory*> factory_map;
};

class FactoryA :public Factory{
public:
     FactoryA() {
          register_factory("A", this);
     }
     virtual AbstractObject* do_create() {
          return new      ConcreteObjectA;
     }    
};

class FactoryB :public Factory{
public:
     FactoryB() {
          register_factory("B", this);
     }
     virtual AbstractObject* do_create() {
          return new      ConcreteObjectB;
     }    
};

class FactoryNULL :public Factory{
public:
     FactoryNULL() {
          register_factory("NULL", this);
     }
     virtual AbstractObject* do_create() {
          return new      ConcreteObjectNULL;
     }    
};

FactoryA factory_A;
FactoryB factory_B;
FactoryNULL factory_NULL;
// 以上对象的定义一般作为全局对象定义在对应Factory类实现的cpp文件中

Factory factory;
AbstractObject* obj_A = factory.create_object("A");
AbstractObject* obj_B = factory.create_object("B");