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

您可以创建一个只知道Base类的工厂，如下所示：

将纯虚方法添加到基类：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();
    }   
  }
};

使用所有类型初始化工厂，您可以从中获取初始化对象类型的指针。

Answer 2

从评论中，我认为你是在追求这样的事情：

    class ISerialNumber
    {
    public:
        static ISerialNumber* Create( const string& number )
        {
            // instantiate and return a concrete class that 
            // derives from ISerialNumber, or NULL
        }

        virtual void DoSerialNumberTypeStuff() = 0;
    };

    class SerialNumberedObject
    {
    public:
        bool Initialise( const string& serialNum ) 
        {
            m_pNumber = ISerialNumber::Create( serialNum );
            return m_pNumber != NULL;
        }

        void DoThings()
        {
            m_pNumber->DoSerialNumberTypeStuff();
        }

    private:
        ISerialNumber* m_pNumber;
    };

（由于这是一个关于更高级概念的问题，保护免受无效/无效指针问题仍然是读者的练习。）

Answer 3

为什么要在这里继承遗产？据我所知，所有Chips实例的行为都是相同的。这种行为是味道由序列号定义。

如果序列号只改变了一些东西，那么你可以在运行时根据序列号使用简单的映射注入或查找行为（std :: function）（为什么复杂的东西！）。这种方式通过序列号映射在不同芯片之间共享通用行为。

如果序列号改变了很多东西，那么我认为你的设计有点倒退。在这种情况下，您真正拥有的是定义芯片配置的序列号，您的设计应该反映出来。像这样：

class SerialNumber {
public:
    // Maybe use a builder along with default values
    SerialNumber( .... ); 
    // All getters, no setters.
    string getFlavour() const;
private:
    string flavour;
    // others (package colour, price, promotion, target country etc...)
}

class Chips {
public:
    // Do not own the serial number... 'tis shared.
    Chips(std::shared_ptr<SerialNumber> poSerial):m_poSerial{poSerial}{} 
    Chips(int shelf, SerialNumber oSerial):m_poSerial{oSerial}, m_nShelf{shelf}{}
    string GetFlavour() {return m_poSerial->getFlavour()};
    int GetShelf() {return m_nShelf;}
protected:
    std::shared_ptr<SerialNumber> m_poSerial;
    int m_nShelf;
}

// stores std::shared_ptr but you could also use one of the shared containers from boost.
Chips pringles{ chipMap.at("standard pringles - sour cream") };

这样一旦您的产品有一组SerialNumbers，产品行为就不会改变。唯一的变化是封装在SerialNumber中的“配置”。意味着Chips类不需要更改。无论如何，某人需要知道如何建立这个类。当然，您也可以使用基于模板的注入，但是您的代码需要注入正确的类型。

最后一个想法。如果SerialNumber ctor接受了一个字符串（例如XML或JSON），那么您可以让程序在经理类型人员定义之后在运行时读取配置。这会将业务需求与代码分离，这将成为面向未来的有力方法。

哦......我建议不要使用匈牙利表示法。如果更改对象或参数的类型，则还必须更改名称。更糟糕的是你可能会忘记改变它们而其他人会做出错误的假设。除非您使用vim / notepad进行编程，否则IDE将以更清晰的方式为您提供该信息。

@ user1158692 - 实例化Chips的一方只需要了解我提议的某个设计中的SerialNumber，并且该提议的设计规定了SerialNumber class用于配置Chips类。在这种情况下，使用Chips的人应该了解SerialNumber，因为他们有亲密的关系。类之间的关系是完全它应该通过构造函数注入的原因。当然，如果必要的话，将其更改为使用setter是非常非常简单的，但由于表示的关系，这是我不鼓励的。

我真的怀疑在不知道序列号的情况下创建芯片实例是绝对必要的。我认为这是一个应用程序问题，而不是类的设计所需要的问题。此外，没有SerialNumber，该类不是很有用，如果你确实允许构造没有SerialNumber的类，你需要使用默认版本（要求Chips知道如何构建其中一个或使用全局引用！）或者你最终会通过大量检查来污染课程。

关于你对shared_ptr的投诉......你究竟如何建议明确所有权语义和责任？也许原始指针将是你的解决方案，但这是危险的，不清楚。 shared_ptr清楚地让设计人员知道他们没有指针并且不对它负责。

比工厂更好的设计模式？

3 个答案: