c++ - 比工厂更好的设计模式？

Question

在我现在创建的代码中，我有一个对象可以属于两个离散类型，由序列号区分。像这样:

class Chips {
public:
    Chips(int shelf) {m_nShelf = shelf;}
    Chips(string sSerial) {m_sSerial = sSerial;}
    virtual string GetFlavour() = 0;
    virtual int GetShelf() {return m_nShelf;}
protected:
    string m_sSerial;
    int m_nShelf;
}

class Lays : Chips {
    string GetFlavour() 
    {
        if (m_sSerial[0] == '0') return "Cool ranch";
        else return "";
    }
}

class Pringles : Chips {
    string GetFlavour() 
    {
        if (m_sSerial.find("cool") != -1) return "Cool ranch";
        else return "";
    }
}

现在，实现这一点的明显选择是使用工厂设计模式。手动检查哪个序列属于哪个类类型不会太困难。

但是，这需要有一个知道所有其他类并按名称 引用它们的类，这几乎不是真正通用的，尤其是当我最终不得不添加一大堆子类时。

更复杂的是，在我知道它的实际序列号之前，我可能不得不保留一个对象一段时间，这意味着我可能不得不编写充满虚拟函数的基类，而不是保持抽象并以某种方式替换它当我获得连续剧时，使用其中一个子类的实例。这也不太理想。

工厂设计模式真的是解决这个问题的最佳方法吗？或者有人有更好的主意吗？

Answer 1

你可以创建一个只知道基类的工厂，像这样:

将纯虚方法添加到基类:virtual Chips* clone() const=0; 并为所有派生实现它，就像 operator= 但要返回指针到一个新的派生。 (如果你有析构函数，它也应该是虚拟的)

现在你可以定义一个工厂类了:

Class ChipsFactory{
  std::map<std::string,Chips*> m_chipsTypes;

public:
  ~ChipsFactory(){
     //delete all pointers... I'm assuming all are dynamically allocated.
     for( std::map<std::string,Chips*>::iterator it = m_chipsTypes.begin();
          it!=m_chipsTypes.end(); it++) {
        delete it->second;
     }
  }
  //use this method to init every type you have
  void AddChipsType(const std::string& serial, Chips* c){
    m_chipsTypes[serial] = c;
  }      
  //use this to generate object
  Chips* CreateObject(const std::string& serial){
    std::map<std::string,Chips*>::iterator it = m_chipsTypes.find(serial);
    if(it == m_chipsTypes.end()){
       return NULL;
    }else{
       return it->clone();
    }   
  }
};

用所有类型初始化工厂，你可以从中得到初始化对象类型的指针。