开关问题的更实用的解决方案:

class APIHandlerImpl
{

// define map of "cases"
std::map<string, std::function<void(server*, websocketpp::connection_hdl, string)>> in_events;

public:
    APIHandlerImpl()
    {
        // bind handler method in constructor
        in_events["/hello"] = std::bind(&APIHandlerImpl::handleHello, this, _1, _2, _3);
        in_events["/bye"] = std::bind(&APIHandlerImpl::handleBye, this, _1, _2, _3);
    }

    void onEvent(string event = "/hello", string data = "{}")
    {
        // execute event based on incomming event
        in_events[event](s, hdl, data);
    }

    void APIHandlerImpl::handleHello(server* s, websocketpp::connection_hdl hdl, string data)
    {
        // ...
    }

    void APIHandlerImpl::handleBye(server* s, websocketpp::connection_hdl hdl, string data)
    {
        // ...
    }
}

这是因为c++将开关转换为跳转表。它对输入数据执行简单的操作，并在不进行比较的情况下跳转到适当的地址。因为字符串不是一个数字，而是一个数字数组，所以c++不能从它创建一个跳转表。

movf    INDEX,W     ; move the index value into the W (working) register from memory
addwf   PCL,F       ; add it to the program counter. each PIC instruction is one byte
                    ; so there is no need to perform any multiplication. 
                    ; Most architectures will transform the index in some way before 
                    ; adding it to the program counter

table                   ; the branch table begins here with this label
    goto    index_zero  ; each of these goto instructions is an unconditional branch
    goto    index_one   ; of code
    goto    index_two
    goto    index_three

index_zero
    ; code is added here to perform whatever action is required when INDEX = zero
    return

index_one
...

(代码来自维基百科https://en.wikipedia.org/wiki/Branch_table)

原因与类型系统有关。C/ c++并不真正支持字符串作为类型。它确实支持常量字符数组的概念，但它并没有真正完全理解字符串的概念。

为了生成switch语句的代码，编译器必须理解两个值相等意味着什么。对于int和enum这样的项，这是一个微不足道的比特比较。但是编译器应该如何比较2个字符串值呢?区分大小写，不敏感，文化意识等等……如果没有对弦的充分认识，就不能准确地回答这个问题。

此外，C/ c++ switch语句通常生成为分支表。为字符串样式切换生成分支表远没有那么容易。

你不能在开关情况下使用字符串。只允许int和char类型。相反，您可以尝试用enum表示字符串，并在switch case块中使用它

enum MyString(raj,taj,aaj);

在switch case语句中使用它。

std::map + c++ 11没有枚举的lambdas模式

潜在的平摊O(1)的unordered_map:在c++中使用HashMap的最佳方式是什么?

#include <functional>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>

int main() {
    int result;
    const std::unordered_map<std::string,std::function<void()>> m{
        {"one",   [&](){ result = 1; }},
        {"two",   [&](){ result = 2; }},
        {"three", [&](){ result = 3; }},
    };
    const auto end = m.end();
    std::vector<std::string> strings{"one", "two", "three", "foobar"};
    for (const auto& s : strings) {
        auto it = m.find(s);
        if (it != end) {
            it->second();
        } else {
            result = -1;
        }
        std::cout << s << " " << result << std::endl;
    }
}

输出:

one 1
two 2
three 3
foobar -1

在静态方法中使用

要在类中有效地使用这种模式，可以静态地初始化lambda映射，否则每次从头构建时都要付出O(n)。

在这里，我们可以摆脱静态方法变量的{}初始化:类方法中的静态变量，但我们也可以使用在:c++中的静态构造函数?我需要初始化私有静态对象

必须将lambda上下文捕获[&]转换为参数，否则将未定义:const static auto lambda与capture by reference一起使用

示例，产生与上面相同的输出:

#include <functional>
#include <iostream>
#include <string>
#include <unordered_map>
#include <vector>

class RangeSwitch {
public:
    void method(std::string key, int &result) {
        static const std::unordered_map<std::string,std::function<void(int&)>> m{
            {"one",   [](int& result){ result = 1; }},
            {"two",   [](int& result){ result = 2; }},
            {"three", [](int& result){ result = 3; }},
        };
        static const auto end = m.end();
        auto it = m.find(key);
        if (it != end) {
            it->second(result);
        } else {
            result = -1;
        }
    }
};

int main() {
    RangeSwitch rangeSwitch;
    int result;
    std::vector<std::string> strings{"one", "two", "three", "foobar"};
    for (const auto& s : strings) {
        rangeSwitch.method(s, result);
        std::cout << s << " " << result << std::endl;
    }
}

在许多情况下，您可以通过从字符串中提取第一个字符并打开它来进行额外的工作。如果您的case以相同的值开始，可能最终必须在charat(1)上进行嵌套切换。任何阅读您的代码的人都会喜欢一个提示，因为大多数人会只使用if-else-if