Question

有一些讨厌的遗留代码。

std::string xxx = GetCommand(); // get "CommandX";
if (xxx == "Command1")
{
    return new Command1();
}
else if (xxx == "Command2")
{
    return new Command2();
}
...
else if (xxx == "Command100")
{
    return new Command100();
}

我想改进这种代码结构有太多的比较。所以我把它们放到地图上。

for (int i = 0; i < GetCommandCount(); ++i)
{
    // key is a command string
    // value is a function pointer which creates it's instance
    map.insert(command, a function pointer);
}

// then

ICommand* pCommand = map.getInstance(command);

但是，如果有新的命令，这种方式必须每次都有附加功能。是的，功能可能是合理的。但是所有函数都只是return new CommandNNN();我想有办法删除重复。

你觉得怎么样？

Answer 1

由于所有函数都是return new CommandNNN();，因此您可以使用模板函数：

template <class T>
CommandBase* createCommand() {
    return new T();
}

并在地图中绑定到此函数：

map.insert(std::make_pair("Command1", &createCommand<Command1>));
map.insert(std::make_pair("Command2", &createCommand<Command2>));
map.insert(std::make_pair("Command3", &createCommand<Command3>));

这使您可以避免为每个命令创建新功能。但是，map.insert - 陈述中仍然存在一些重复。这可以通过使用宏来进一步减少，如果这是你的一杯茶：

#define INSERT(cmd) map.insert(std::make_pair(#cmd, &createCommand<cmd>));

INSERT(Command1);
INSERT(Command2);
INSERT(Command3);

#undef INSERT

或

#define INSERT(n) map.insert(std::make_pair("Command" #n, &createCommand<Command ## n>));

INSERT(1);
INSERT(2);
INSERT(3);

#undef INSERT

我怀疑你甚至可以让预处理器为你做一些计数，但这不属于我的域名。

应用更多的宏以及一些全局状态，这两者都被许多人所厌恶，你可以得到更紧密的耦合：

#include <map>
#include <string>
#include <cassert>

class CommandBase {};

static std::map<std::string, CommandBase* (*)()> g_commandMap;

template <class C>
CommandBase* createCommand() {
    return new C();
}

class CommandRegistrer {
public:
    CommandRegistrer(const std::string& name, CommandBase* (*instantiator)()) {
        g_commandMap.insert(std::make_pair(name, instantiator));
    }
};

#define COMMAND_CLASS(n) \
    class Command##n; \
    CommandRegistrer g_commandRegistrer##n("Command" #n, createCommand<Command##n>); \
    class Command##n : public CommandBase

COMMAND_CLASS(1) { /* implementation here */ };
COMMAND_CLASS(2) { /* implementation here */ };

int main() {
    assert(g_commandMap.find("Command1") != g_commandMap.end());
}

Answer 2

如果您使用的是C ++ 11，则可以使用内联lambda来完成所有内容：

class Object
{
};

class Command1 : public Object
{
};

// etc

typedef std::map<std::string, std::function<Object*()>> FunctionMap;
typedef std::pair<std::string, std::function<Object*()>> FunctionPair;

FunctionMap funcMap;
funcMap.insert(FunctionPair("Command1", []()
    {
        return new Command1();
    }));

Answer 3

为什么不制作一个静态数组

static struct cmdthing {
    const char *cmd;
    void (*fun)();
} commands[] = {
    {..,..},
    {..,..},
    ...
};

for(const cmdthing *p=commands;p<commands+sizeof(commands)/sizeof(*commands);++p)
    if(!strcmp(p->cmd,cmd)) return (*(p->fun))();

或类似的东西？

Answer 4

您可以将地图作为工厂的私人成员，例如：

CommandFactory{
 private:
  std::map< std::string, ICommand*> m_commands;
 public:
  CommandFactory();
  ICommand* getInstance()const;
  virtual ~CommandFactory();
};

在构造函数中注册所有操作，如：

CommandFactory(){
  m_commands.insert( std::pair< std::string, ICommand*>("commandName", new Command) );
}

ICommand是一个接口，因此创建一个虚方法invoke（）

class ICommand{
  public:
    ICommand();
    virtual bool invoke()=0;
    virtual ~ICommand();
};

但通常一个简单的工厂可能就足够了。

Answer 5

只需解析字符串以返回一个int然后通过一个开关。应该快而小。如果需要，case可以很容易地生成。样本非常明显：

int ToCommandID(const std::string& CommandX) { evaluate and return X as an int }

Command* NewCommand() {
    const std::string xxx(GetCommand()); // get "CommandX";
    const int commandID(ToCommandID(xxx));
    switch (commandID) {
        case 1 : return new Command1();
        case 2 : return new Command2();
        case 3 : return new Command3();
        case 4 : return new Command4();
        case 5 : return new Command5();
        case 6 : return new Command6();
        case 7 : return new Command7();
        case 8 : return new Command8();
        case 9 : return new Command9();
        case 10 : return new Command10();
        case 11 : return new Command11();
        case 12 : return new Command12();
        case 13 : return new Command13();
        case 14 : return new Command14();
        ...
        default : {
            assert(0 && "oh no!");
...

抱歉，今天没有花哨的语言功能TT。当然，您可以通过宏运行它并减少字符数，或者您可以将其标记为生成代码并在2分钟内完成。

如何重构这个结构，if-else-if-else-if * 100

5 个答案: