有没有可能在C&x2B+；是否符合开/关原则？ 在我正在C++中工作的项目中，我需要为消息在消息中出现时创建对象。我当前正在使用隐藏对象的创建： // very psuedo-codey Message* MessageFactory::CreateMessage(InputStream& stream) { char header = stream.ReadByte(); switch (header) { case MessageOne::Header: return new MessageOne(stream); case MessageTwo::Header: return new MessageTwo(stream); // etc. } }

我的问题是我很懒，不喜欢在两个地方写类名

在C i中，我会先考虑一下工厂的首次使用（奖金问题：这是一个反射的好用，对吧？），但是因为C++缺乏反射，这是不可能的。我曾考虑过使用某种注册表，以便消息在启动时在工厂中注册，但这受到了限制

问题是，在开放/关闭原理的基础上，是否可以在C++中实现这种工厂？

---

编辑：显然我想得太多了。我想问一个“在C++中如何实现这一点”的问题，因为用其他语言进行反射非常容易

您可以将创建消息的类（MessageOne、MessageTwo…）转换为消息工厂，并在初始化时向顶级MessageFactory注册它们

消息工厂可以保存MessageX:：Header->MessageX工厂类映射实例的映射

在CreateMessage中，您将根据消息头找到MessageXFactory的实例，检索对MessageXFactory的引用，然后调用将返回实际MessageX实例的方法

对于新消息，您不再需要修改“开关”，只需向TopMessageFactory添加一个new MessageXFactory实例

例如：

#include <iostream>
#include <map>
#include <string>

using namespace std;

struct Message
{
    static const int id = 99;
    virtual ~Message() {}
    virtual int msgId() { return id; }
};

struct NullMessage : public Message
{
    static const int id = 0;
    virtual int msgId() { return id; }
};

struct MessageOne : public Message
{
    static const int id = 1;
    virtual int msgId() { return id; }
};

struct MessageTwo : public Message
{
    static const int id = 2;
    virtual int msgId() { return id; }
};

struct MessageThree : public Message
{
    static const int id = 3;
    virtual int msgId() { return id; }
};

struct IMessageFactory
{
    virtual ~IMessageFactory() {}
    virtual Message * createMessage() = 0;
};

struct MessageOneFactory : public IMessageFactory
{
    MessageOne * createMessage()
    {
        return new MessageOne();
    }
};

struct MessageTwoFactory : public IMessageFactory
{
    MessageTwo * createMessage()
    {
        return new MessageTwo();
    }
};

struct TopMessageFactory
{
    Message * createMessage(const string& data)
    {
        map<string, IMessageFactory*>::iterator it = msgFactories.find(data);
        if (it == msgFactories.end()) return new NullMessage();

        return (*it).second->createMessage();
    }

    bool registerFactory(const string& msgId, IMessageFactory * factory)
    {
        if (!factory) return false;
        msgFactories[msgId] = factory;
        return true;
    }

    map<string, IMessageFactory*> msgFactories;
};

int main()
{
    TopMessageFactory factory;
    MessageOneFactory * mof = new MessageOneFactory();
    MessageTwoFactory * mtf = new MessageTwoFactory();

    factory.registerFactory("one", mof);
    factory.registerFactory("two", mtf);

    Message * msg = factory.createMessage("two");
    cout << msg->msgId() << endl;

    msg = factory.createMessage("one");
    cout << msg->msgId() << endl;
}

#包括
#包括
#包括
使用名称空间std；
结构消息
{
静态常量int id=99；
虚拟~Message（）{}
虚拟int msgId（）{return id；}
};
结构NullMessage:公共消息
{
静态常量int id=0；
虚拟int msgId（）{return id；}
};
结构MessageOne：公共消息
{
静态常量int id=1；
虚拟int msgId（）{return id；}
};
结构MessageTwo：公共消息
{
静态常量int id=2；
虚拟int msgId（）{return id；}
};
结构消息三：公共消息
{
静态常量int id=3；
虚拟int msgId（）{return id；}
};
结构IMessageFactory
{
虚拟~IMessageFactory（）{}
虚拟消息*createMessage（）=0；
};
结构MessageOneFactory:公共IMessageFactory
{
MessageOne*createMessage（）
{
返回新的MessageOne（）；
}
};
结构MessageTwoFactory:公共IMessageFactory
{
MessageTwo*createMessage（）
{
返回新的MessageTwo（）；
}
};
结构TopMessageFactory
{
消息*createMessage（常量字符串和数据）
{
迭代器it=msgFactories.find（数据）；
if（it==msgFactories.end（））返回新的NullMessage（）；
return（*it）.second->createMessage（）；
}
布尔寄存器工厂（常量字符串和msgId，IMessageFactory*工厂）
{
如果（！工厂）返回错误；
msgFactories[msgId]=工厂；
返回true；
}
msgf工厂地图；
};
int main（）
{
TopMessage工厂；
MessageOneFactory*mof=newmessageonefactory（）；
MessageTwoFactory*mtf=新建MessageTwoFactory（）；
工厂注册工厂（“一家”，财政部）；
工厂注册工厂（“两个”，mtf）；
Message*msg=factory.createMessage（“两条”）；
cout msgId（）您可以将创建消息的类（MessageOne、MessageTwo…）转换为消息工厂，并在初始化时向顶级MessageFactory注册它们

消息工厂可以保存MessageX:：Header->MessageX工厂类映射实例的映射

在CreateMessage中，您将根据消息头找到MessageXFactory的实例，检索对MessageXFactory的引用，然后调用将返回实际MessageX实例的方法

对于新消息，您不再需要修改“开关”，只需向TopMessageFactory添加一个new MessageXFactory实例

例如：

#include <iostream>
#include <map>
#include <string>

using namespace std;

struct Message
{
    static const int id = 99;
    virtual ~Message() {}
    virtual int msgId() { return id; }
};

struct NullMessage : public Message
{
    static const int id = 0;
    virtual int msgId() { return id; }
};

struct MessageOne : public Message
{
    static const int id = 1;
    virtual int msgId() { return id; }
};

struct MessageTwo : public Message
{
    static const int id = 2;
    virtual int msgId() { return id; }
};

struct MessageThree : public Message
{
    static const int id = 3;
    virtual int msgId() { return id; }
};

struct IMessageFactory
{
    virtual ~IMessageFactory() {}
    virtual Message * createMessage() = 0;
};

struct MessageOneFactory : public IMessageFactory
{
    MessageOne * createMessage()
    {
        return new MessageOne();
    }
};

struct MessageTwoFactory : public IMessageFactory
{
    MessageTwo * createMessage()
    {
        return new MessageTwo();
    }
};

struct TopMessageFactory
{
    Message * createMessage(const string& data)
    {
        map<string, IMessageFactory*>::iterator it = msgFactories.find(data);
        if (it == msgFactories.end()) return new NullMessage();

        return (*it).second->createMessage();
    }

    bool registerFactory(const string& msgId, IMessageFactory * factory)
    {
        if (!factory) return false;
        msgFactories[msgId] = factory;
        return true;
    }

    map<string, IMessageFactory*> msgFactories;
};

int main()
{
    TopMessageFactory factory;
    MessageOneFactory * mof = new MessageOneFactory();
    MessageTwoFactory * mtf = new MessageTwoFactory();

    factory.registerFactory("one", mof);
    factory.registerFactory("two", mtf);

    Message * msg = factory.createMessage("two");
    cout << msg->msgId() << endl;

    msg = factory.createMessage("one");
    cout << msg->msgId() << endl;
}

#包括
#包括
#包括
使用名称空间std；
结构消息
{
静态常量int id=99；
虚拟~Message（）{}
虚拟int msgId（）{return id；}
};
结构NullMessage:公共消息
{
静态常量int id=0；
虚拟int msgId（）{return id；}
};
结构MessageOne：公共消息
{
静态常量int id=1；
虚拟int msgId（）{return id；}
};
结构MessageTwo：公共消息
{
静态常量int id=2；
虚拟int msgId（）{return id；}
};
结构消息三：公共消息
{
静态常量int id=3；
虚拟int msgId（）{return id；}
};
结构IMessageFactory
{
虚拟~IMessageFactory（）{}
虚拟消息*createMessage（）=0；
};
结构MessageOneFactory:公共IMessageFactory
{
MessageOne*createMessage（）
{
返回新的MessageOne（）；
}
};
结构MessageTwoFactory:公共IMessageFactory
{
MessageTwo*createMessage（）
{
返回新的MessageTwo（）；
}
};
结构TopMessageFactory
{
消息*createMessage（常量字符串和数据）
{
迭代器it=msgFactories.find（数据）；
if（it==msgFactories.end（））返回新的NullMessage（）；
return（*it）.second->createMessage（）；
}
布尔寄存器工厂（常量字符串和msgId，IMessageFactory*工厂）
{
如果（！工厂）返回错误；
msgFactories[msgId]=工厂；
返回true；
}
msgf工厂地图；
};
int main（）
{
TopMessage工厂；
MessageOneFactory*mof=newmessageonefactory（）；
MessageTwoFactory*mtf=新建MessageTwoFactory（）；
工厂注册工厂（“一家”，财政部）；
工厂注册工厂（“两个”，mtf）；
Message*msg=factory.createMessage（“两条”）；
cout msgId（）我认为开放/封闭方法和DRY是好的原则。但它们不是神圣的。目标应该是使代码可靠和可维护。如果必须执行