有一些令人讨厌的遗留代码.

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);

但是,如果新的命令来了,这种方式必须每次增加一些功能.
是的,这些功能可能是合理的.但是所有的功能只是返回新的CommandNNN();我想有办法删除重复.

你怎么想？

由于所有函数都返回新的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-statements中仍然会有一些重复.这可以通过使用宏进一步减少,如果这是你的一杯茶：

#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());
}

我最近升级到Visual Studio 2015(更新1)并且已按照我希望的方式进行配置,但是我对花括号的格式化有点麻烦！我假设第二个代码示例是更接受的约定,但我似乎无法正确设置我的设置.我在这做错了什么？

Visual Studio当前正在自动格式化我的代码,请注意else {

public static string Gender(string x)
    {
        if (x == "M")
        {
            return "Male";
        }
        else if (x == "F")
        {
            return "Female";
        }
        else {
            return "UnkNown";
        }
    }

我想我的代码是这样自动格式化的

public static string Gender(string x)
    {
        if (x == "M")
        {
            return "Male";
        }
        else if (x == "F")
        {
            return "Female";
        }
        else
        {
            return "UnkNown";
        }
    }

我有Visual Studio 2015 Update 1,并将其设置为格式,就像在第二个代码段中一样.

一个重要的设置是取消选中“将其他地方放在新线上”选项.

如果这还不够,我会发布一个包含我所有设置的屏幕截图(http://imgur.com/XPvH8pI)

我正在寻找一种重构日志的方法,如果/ else if / else语句也有一些嵌套.这些块也使用了很多常见的对象.我的目标是将代码分解为提取到不同类的可管理单元,并使其可插拔,以防我需要覆盖新的条件.

这里有一些虚拟代码来说明：

List<ValidationResult> validationResults = new ...;
Inspector inspector = commonInspector;
bool additionalOp = commonFlag;
HashSet<Thing> thingstocheck = theThings;
foreach (var thing in thingstocheck)
{
    if (IsCandy(thing) && thing.IsWrapped && thing.IsHard)
    {
        var inspected = inspector.Inspect(thing.Value);
        if (inspected != thing.Value)
        {
            validationResults.Add(new ...);
            if (additionalOp)
            {
                thing.Taste();
            }
        }
    }
    else if (IsChocolate(thing))
    {
        var sweet = (Sweet)thing;
        List<BadCalories> badCalories;
        while (var calorie in sweet.Calories)
        {
            if (calorie.IsGood)
                continue;
            badCalories.Add(calorie);
        }

        foreach (var badCal in badCalories)
        {
            var inspected = inspector.Inspect(badCal.Value);
            if (inspected != badCal.Value)
            {
                validationResults.Add(new ...);
                if (additionalOp)
                {
                    badCal.Taste();
                }
            }
        }
    }
    else
    {
        if(thing ...)
        else if (thing ...)
    }

我阅读了一些文章/可能适用的各种模式/实践的帖子,但代码的依赖关系让我对应用概念有点复杂化.我现在对代码的关注程度有点过了一段时间没有任何帮助,因此很难从微观管理中脱颖而出.

您可以将大范围块分解为单独的函数.

if(IsHardWrappedCandy(thing))
  ValidateHardWrappedCandy(thing);
else if (IsChocolateCandy(thing))
  ValidateChocolateCandy(thing);

还有interitance,你可以创建糖果类和封装行为：

public abstract class CandyBase
{
    public abstract void Validate();
}
public class HardWrappedCandy : CandyBase
{
  public override void Validate()
  {
     // Todo: Validation logic
  }
}

然后你的代码将是：

foreach(var candy in candies)
   candy.Validate();

当然,你需要标准化参数等,但你明白了.

阅读“清洁代码”一书,它有很多关于如何重构的好主意. http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882