C++ 我是否正确使用函数指针？

我有一个函数在伪代码中看起来像这样：

std::string option = "option1" // one of n options, user supplied

for (int i = 0; i < 100000; i++) {

    if (option == "option1") {
        doFunction1a();
    } else if (option == "option2") {
        doFunction2a();
    } else if (option == "option3") {
        doFunction3a();
    }

    //  more code...

    if (option == "option1") {
        doFunction1b();
    } else if (option == "option2") {
        doFunction2b();
    } else if (option == "option3") {
        doFunction3b();
    }

}

std:：string option=“option1”//n个选项之一，用户提供
对于（int i=0；i<100000；i++）{
如果（选项==“选项1”）{
do1a（）；
}否则如果（选项==“选项2”）{
do2a（）；
}否则如果（选项==“选项3”）{
do3a（）；
}
//更多代码。。。
如果（选项==“选项1”）{
do1b（）；
}否则如果（选项==“选项2”）{
do2b（）；
}否则如果（选项==“选项3”）{
do3b（）；
}
}

但是，我可以通过如下操作避免循环中重复的if语句：

std::string option = "option1" // one of n options, user supplied

int (*doFunctiona)(int, int);
int (*doFunctionb)(int, int);

if (option == "option1") {
    doFunctiona = doFunction1a;
    doFunctionb = doFunction1b;
} else if (option == "option2") {
    doFunctiona = doFunction2a;
    doFunctionb = doFunction2b;
} else if (option == "option3") {
    doFunctiona = doFunction3a;
    doFunctionb = doFunction3b;
}

for (int i = 0; i < 100000; i++) {

    doFunctiona();

    //  more code...

    doFunctionb();

}

std:：string option=“option1”//n个选项之一，用户提供
int（*dofunction）（int，int）；
int（*dob）（int，int）；
如果（选项==“选项1”）{
doFunctiona=doFunction1a；
doFunctionb=doFunction1b；
}否则如果（选项==“选项2”）{
doFunctiona=doFunction2a；
doFunctionb=doFunction2b；
}否则如果（选项==“选项3”）{
doFunctiona=doFunction3a；
doFunctionb=doFunction3b；
}
对于（int i=0；i<100000；i++）{
doFunctiona（）；
//更多代码。。。
dob（）；
}

我意识到这对性能几乎没有影响（函数花费的时间决定了执行if语句所需的时间）

---

然而，就“良好的编码实践”而言，这是设置变量函数调用的好方法吗？“好”的意思是：（1）易于扩展，未来很容易有20个选项；2） 产生可读代码。我希望有某种标准的方法来实现这一点。如果没有，请随时以意见为基础关闭。

只需使用

无序地图

，省去“如果-否则如果”狂欢：

std::unordered_map<std::string, std::vector<int (*)(int, int)>> functions;
functions.insert({ "option1", { doFunction1a, doFunction1b } });
...
const auto& vec = functions["option1"];
for(auto& f : vec) f(1, 2);

std:：无序映射函数；
插入（{“option1”，{doFunction1a，doFunction1b}）；
...
const auto&vec=函数[“option1”]；
对于（自动&f:vec）f（1,2）；

除了使用map之外，我建议使用

std:：function

和lambdas，这将为您提供更大的灵活性和更友好的语法（至少对我来说）：

std:：无序映射函数{
{
“选择1”，
[] { 
functional（）；
函数b（）；
}
},
{
“选择2”，
[] { 
函数c（）；
函数d（）；
}
}
};
autooptionfuncit=functions.find（“option1”）；
if（optionFuncIt！=functions.end（））{
optionFuncIt->second（）；
}否则{
我喜欢函数指针数组。你所做的看起来很合理。映射比较干净，但是std:：ones会命中堆。看起来还可以。不过我会使用带有虚拟函数的类。也许“基于策略的设计”会有用。
std::unordered_map<std::string, std::function<void()>> functions {
    {
        "option1", 
        [] { 
            functionA();
            functionB();
        }
    },
    {
        "option2", 
        [] { 
            functionC();
            functionD();
        }
    }
};

auto optionFuncIt = functions.find("option1");
if (optionFuncIt != functions.end()) {
     optionFuncIt->second();
} else {
     std::cerr << "Invalid option name" << std::endl;
}