哈希去胜利

Question

通常我需要根据非POD常量元素的值选择要做的事情，如下所示：

switch( str ) {
  case "foo": ...
  case "bar": ...
  default:    ...
}

可悲的是switch只能与整数一起使用：error: switch quantity not an integer。

实现此类事情最简单的方法就是拥有if s序列：

if( str == "foo" )      ...
else if( str == "bar" ) ...
else                    ...

但是这个解决方案看起来很脏并且应该花费O（n），其中n是案例数，而在最坏的情况下，使用二进制搜索，这段代码可能花费O（log n）。

使用一些数据结构（如Maps）可以获得表示字符串的整数（O（log n）），然后使用O（1）switch，或者可以实现静态通过以正确的方式嵌套if来进行二进制排序，但这些 hacks 仍然需要大量编码，使一切变得更加复杂和难以维护。

最好的方法是什么？（快速，干净，简单，因为switch语句是）

Answer 1

使用一些令人讨厌的宏和模板魔法，可以在编译时使用漂亮的语法获得展开的二进制搜索 - 但MATCHES（“case”）必须排序：fastmatch.h

NEWMATCH
MATCH("asd")
  some c++ code
MATCH("bqr")
  ... the buffer for the match is in _buf
MATCH("zzz")
  ...  user.YOURSTUFF 
/*ELSE 
  optional
*/
ENDMATCH(xy_match)

这将生成（大致）函数bool xy_match(char *&_buf,T &user)，因此它必须位于外层。称它为例如用：

xy_match("bqr",youruserdata);

break是隐含的，你不能堕落。对不起，它也没有大量记录。但你会发现，有更多的使用可能性，看看。注意：仅使用g ++进行测试。

更新C ++ 11：

Lambdas和初始化列表使事情变得更漂亮（不涉及宏！）：

#include <utility>
#include <algorithm>
#include <initializer_list>

template <typename KeyType,typename FunPtrType,typename Comp>
void Switch(const KeyType &value,std::initializer_list<std::pair<const KeyType,FunPtrType>> sws,Comp comp) {
  typedef std::pair<const KeyType &,FunPtrType> KVT;
  auto cmp=[&comp](const KVT &a,const KVT &b){ return comp(a.first,b.first); };
  auto val=KVT(value,FunPtrType());
  auto r=std::lower_bound(sws.begin(),sws.end(),val,cmp);
  if ( (r!=sws.end())&&(!cmp(val,*r)) ) {
    r->second();
  } // else: not found
}

#include <string.h>
#include <stdio.h>
int main()
{
  Switch<const char *,void (*)()>("ger",{ // sorted:                      
    {"asdf",[]{ printf("0\n"); }},
    {"bde",[]{ printf("1\n"); }},
    {"ger",[]{ printf("2\n"); }}
  },[](const char *a,const char *b){ return strcmp(a,b)<0;});           
  return 0;
}

这就是主意。可以在此处找到更完整的实现：switch.hpp。

2016年更新：编译时间trie

我对此问题的最新看法是使用高级c ++ 11元编程在编译时生成search-trie。与以前的方法不同，这将处理未排序 case-branches / strings就好了;它们只需要是字符串文字。 G ++也允许使用constexpr，但不能使用clang（从HEAD 3.9.0 / trunk 274233开始）。

在每个trie节点中，使用switch语句来利用编译器的高级代码生成器。

完整的实现可以在github上找到：smilingthax/cttrie。

Answer 2

在C ++中，您可以通过O(lg n)获得std::map<std::string, functionPointerType>表现。（在C中，你可以实现基本相同的但是更难）使用std::map<k, v>::find拉出正确的函数指针，并调用该指针。当然，这不会像语言支持的switch语句那么简单。另一方面，如果你有足够的项目，O(n)和O(lg n)之间会有很大的差异，这可能表明你应该首先选择不同的设计。< / p>

就个人而言，无论如何，我总是发现ELSEIF链更具可读性。

Answer 3

您可以在不使用任何地图或unordered_map的情况下实现它，如下所示。单独比较第一个字符以识别哪个字符串。如果不止一个匹配，那么您可以回退到该case语句中的if / else链。如果没有多个字符串以相同的字母开头，那么比较的数量将大大减少。

char *str = "foo";
switch(*str)
{
case 'f':
    //do something for foo
    cout<<"Foo";
    break;
case 'b':
    //do something for bar
    break;
case 'c':
    if(strcmp(str, "cat") == 0)
    {
        //do something for cat
    }
    else if(strcmp(str, "camel") == 0)
    {
        //do something for camel
    }
}

这看起来是没有任何成本的最佳解决方案，即使它不是标准的。

Answer 4

使用if...else block。你并没有一个令人信服的理由，除了它不是很好看之外，if...else块是最直接的解决方案。

其他一切都需要额外的代码，据说这会增加复杂性。它只是把丑陋的东西移到别处。但在某种程度上，字符串比较仍然必须发生。现在你已经用更多代码覆盖了它。

您可能通过使用地图或哈希地图获得一些性能提升，但您也可以通过简单地选择智能订单来评估if...else块，从而获得相似甚至更好的收益。出于性能原因切换到地图实际上只是过早的微观优化。

Answer 5

在C中，有两种常见的解决方案。第一个是将关键字保存在排序数组中，比如说

typedef struct Keyword {
    const char *word;
    int         sub;
    int         type;
} Keyword;

Keyword keywords[] ={   /* keep sorted: binary searched */
    { "BEGIN", XBEGIN, XBEGIN },
    { "END",   XEND,   XEND },
    { "NF",    VARNF,  VARNF },
    { "atan2", FATAN,  BLTIN },
    ...
};

并对其进行binary search。前面的内容直接来自C大师Brian W. Kernighan的awk源代码。

另一个解决方案， O （min（ m ， n ））如果 n 是输入字符串的长度和 m 最长关键字的长度，是使用有限状态解决方案，例如Lex程序。

Answer 6

这样的事情太复杂了吗？

#include <iostream>
#include <map>

struct object
{
    object(int value): _value(value) {}

    bool operator< (object const& rhs) const
    {
        return _value < rhs._value;
    }

    int _value;
};

typedef void(*Func)();

void f1() {
    std::cout << "f1" << std::endl;
}

void f2() {
    std::cout << "f2" << std::endl;
}

void f3() {
    std::cout << "f3" << std::endl;
}

int main()
{
    object o1(0);
    object o2(1);
    object o3(2);

    std::map<object, Func> funcMap;
    funcMap[o1] = f1;   
    funcMap[o2] = f2;   
    funcMap[o3] = f3;

    funcMap[object(0)](); // prints "f1"
    funcMap[object(1)](); // prints "f2"
    funcMap[object(2)](); // prints "f3"
}

Answer 7

这与lambda和unordered_map解决方案的精神相似，但我认为这是两个世界中最好的，具有非常自然和可读的语法：

#include "switch.h"
#include <iostream>
#include <string>

int main(int argc, const char* argv[])
{
    std::string str(argv[1]);
    Switch(str)
        .Case("apple",  []() { std::cout << "apple" << std::endl; })
        .Case("banana", []() { std::cout << "banana" << std::endl; })
        .Default(       []() { std::cout << "unknown" << std::endl; });    
    return 0;
}

switch.h：

#include <unordered_map>
#include <functional>
template<typename Key>
class Switcher {
public:
    typedef std::function<void()> Func;
    Switcher(Key key) : m_impl(), m_default(), m_key(key) {}
    Switcher& Case(Key key, Func func) {
        m_impl.insert(std::make_pair(key, func));
        return *this;
    }
    Switcher& Default(Func func) {
        m_default = func;
        return *this;
    }
    ~Switcher() {
        auto iFunc = m_impl.find(m_key);
        if (iFunc != m_impl.end())
            iFunc->second();
        else
            m_default();
    }
private:
    std::unordered_map<Key, Func> m_impl;
    Func m_default;
    Key m_key;
};
template<typename Key>
Switcher<Key> Switch(Key key)
{
    return Switcher<Key>(key);
}

Answer 8

以下是有效的示例代码：

这应该有用 （但仅限于4字节或更少的字符串）

这将字符串视为4字节整数。

这被认为是丑陋的，不便携的，“hacky”，并且根本没有好的风格。 但它确实做了你想做的事。

#include "Winsock2.h"
#pragma comment(lib,"ws2_32.lib")

void main()
{
  char day[20];
  printf("Enter the short name of day");

  scanf("%s", day);

  switch(htonl(*((unsigned long*)day)))
  {
    case 'sun\0':
      printf("sunday");
      break;
    case 'mon\0':
      printf("monday");
      break;
    case 'Tue\0':
      printf("Tuesday");
      break;
    case 'wed\0':
      printf("wednesday");
      break;
    case 'Thu\0':
      printf("Thursday");
      break;
    case 'Fri\0':
      printf("friday");
      break;
    case 'sat\0':
      printf("saturday");
      break;
  }
}

在MSVC2010中测试

Answer 9

我想到了一个基于元编程的哈希生成器，您可以使用like in this example。这个是针对c ++ 0x的，但我确信你可以为标准C ++重现它。

Answer 10

你仍然可以使用开关..如果你事先知道标签..（这是非常讨厌的（即没有检查，但只要你有一个有效的空终止字符串，这应该是微不足道的！），我应该想象这比大多数选项都要快吗？

//labels: "abc", "foo", "bar", "ant" "do"

switch(lbl[0])
{
  case 'a':
  {
    switch(lbl[1])
    {
      case 'b': // abc
      case 'n': // ant
      default:  // doofus!
    }
  }
  case 'b':
  {
    switch(lbl[1])
    {
      case 'a': //bar
      default:  // doofus
    }
  }
  case 'd':
  {
    switch(lbl[1])
    {
      case 'o': //do
      default:  // doofus
    }
  }
  case 'f':
  {
    switch(lbl[1])
    {
      case 'o': //foo
      default:  // doofus
    }
  }
}

当然，如果你有一个非常大的“标签”列表，这将变得非常复杂......

Answer 11

您可以使用我的switch macros，它支持所有类型的值。在少数情况下，连续几次使用op==比每次创建地图并查看其中的速度快一个数量级。

 sswitch(s) {
    scase("foo"): {
      std::cout << "s is foo" << std::endl;
      break; // could fall-through if we wanted
    }

    // supports brace-less style too
    scase("bar"):
      std::cout << "s is bar" << std::endl;
      break;

    // default must be at the end
    sdefault():
      std::cout << "neither of those!" << std::endl;
      break;
 }

Answer 12

您可以使用任何类型的c / c ++ switch implementation。你的代码将是这样的：

std::string name = "Alice";

std::string gender = "boy";
std::string role;

SWITCH(name)
  CASE("Alice")   FALL
  CASE("Carol")   gender = "girl"; FALL
  CASE("Bob")     FALL
  CASE("Dave")    role   = "participant"; BREAK
  CASE("Mallory") FALL
  CASE("Trudy")   role   = "attacker";    BREAK
  CASE("Peggy")   gender = "girl"; FALL
  CASE("Victor")  role   = "verifier";    BREAK
  DEFAULT         role   = "other";
END

// the role will be: "participant"
// the gender will be: "girl"

可以使用更复杂的类型，例如std::pairs或支持相等操作的任何结构或类（或快速模式的同义词）。

功能

支持比较或检查相等的任何类型的数据
建立级联嵌套开关状态的可能性。
通过案例陈述打破或贬低的可能性
使用非常量案例表达的可能性
可以通过树搜索启用快速静态/动态模式（对于C ++ 11）

Sintax与语言切换的差异是

大写关键字
需要CASE声明的括号
分号';'不允许在陈述结束时
冒号'：'不允许CASE声明
在CASE声明结尾处需要BREAK或FALL关键字之一

对于使用C++97语言的线性搜索。对于C++11和更现代的可能使用quick模式wuth树搜索，其中返回语句在CASE中变得不被允许。存在C语言实现，其中使用char*类型和零终止字符串比较。

阅读more about此切换实施。

Answer 13

LLVM使用llvm::StringSwitch，如下所示：

Color color = StringSwitch<Color>(argv[i])
   .Case("red", Red)
   .Case("orange", Orange)
   .Case("yellow", Yellow)
   .Case("green", Green)
   .Case("blue", Blue)
   .Case("indigo", Indigo)
   .Cases("violet", "purple", Violet)
   .Default(UnknownColor);

这里的主要胜利是由于哈希冲突没有问题：无论如何，在接受案例之前总是比较实际的字符串。

Answer 14

请注意，即使允许使用const char *切换也无法正常工作。

C String实际上是指向char的指针。像你建议的代码：

// pseudocode (incorrect C!):
switch(str) {
   case "a": ...
   case "b": ...
}

如果我们的语言是一致的 - 它会比较指针值，而不是实际的字符串内容。比较字符串需要strcmp()，因此即使编译器有一个特殊情况，例如“如果我们正在切换char*，请使用strcmp()而不是==（这会反正可能是糟糕的语言设计），然后无论如何，编译器不可能像使用整数和跳转的O（1）hack那样工作。

所以不要为C / C ++感觉不好，因为它不受支持。：）

如果您认为需要可扩展性，我推荐使用地图(string -> funcptr)或(string -> some abstract object)的O（logn）解决方案。如果你不这样做，那么O（n）解决方案没有什么特别的错误。它仍然是清晰，可维护的代码，所以没有什么可以让我感到难过。

Answer 15

前段时间，我编写了一个模板化的类，实现了某种类似的开关，可用于任何数据类型。但是，有一些限制因素限制了其应用领域：

在每个分支上实现的任务必须是函数调用。
要调用的函数只有一个参数（或者没有，或者两个，你可以调整模板，但它必须对所有函数都相同）。
传递给函数的参数值在每种情况下都是相同的（但是在执行开关时给出它。）

例如，您要打开MyType类型的值，如果它等于value1，请调用function1("abc")，如果它等于{{1} }，调用value2（依此类推）。这最终将成为：

function2("abc")

基本上，它包装了一个std :: map容器，保存了对的值/函数。它还可以处理“默认”，这使得交换机如此有趣。它可以很容易地适应其他情况。这是代码：

// set up the object
//               Type  -        function sig       - function arg. type
SWITCH mySwitch< MyType, void(*)(const std::string&), std::string >;
mySwitch.Add( value1, function1 );
mySwitch.Add( value2, function2 );
mySwitch.AddDefault( function_def );

// process the value
MyType a =...// whatever.
mySwitch.Process( a, "abc" );

其他详情are here。

Answer 16

哈希去胜利

您可以使用编译时哈希函数，就像在这个光荣的堆栈溢出answer中一样。如果您创建函数

int_crc32_s在运行时和
int_crc32在编译时返回字符串的哈希值

你被设定了。要处理密钥字符串和大小写字符串的crc的错误匹配，您需要包含对匹配的显式检查。这并没有真正影响性能，因为它只是一次检查，但它使它更加丑陋，宏版本看起来更好。

我发现这两个字符串有same CRC32。

//two strings that yield same crc32
const char* collision1="DeferredAmbient_6_1_18-1of2_5";
const char* collision2="PostEffect_Lighting_18_6-0of1_8_14_13-1of2_19";

没有宏

//without macros (you need to check for collisions)
switch( int_crc32_s(str.c_str()) )
{
    case int_crc32("foo"): if( str=="foo"){std::cout << "foo you\n"; break;}
    case int_crc32("bar"): if( str=="bar"){std::cout << "bar you\n"; break;}
    case int_crc32("baz"): if( str=="baz"){std::cout << "baz you\n"; break;}
    case int_crc32("PostEffect_Lighting_18_6-0of1_8_14_13-1of2_19"):
        if( str=="PostEffect_Lighting_18_6-0of1_8_14_13-1of2_19"){
            std::cout << "jackpot!\n"; break;
        }
    default: std::cout << "just you\n";
}

使用宏

//convenient macros
#define S_SWITCH( X ) const char* SWITCH_KEY(X.c_str()); switch( int_crc32_s(X.c_str()) )
#define S_CASE( X ) case int_crc32(X): if( strcmp(SWITCH_KEY,X) ){ goto S_DEFAULT_LABEL;}
#define S_DEFAULT S_DEFAULT_LABEL: default:

//with macros
S_SWITCH( str )
{
    S_CASE("foo"){ std::cout << "foo you\n"; break; }
    S_CASE("bar"){ std::cout << "bar you\n"; break; }
    S_CASE("baz"){ std::cout << "baz you\n"; break; }
    S_CASE("PostEffect_Lighting_18_6-0of1_8_14_13-1of2_19"){ std::cout << "jackpot!\n"; break; }
    S_DEFAULT{ std::cout << "just you\n"; }
}

完整实施[gist]

// This is a demonstration of using a COMPILE-TIME hash to do a
// switch statement with a string to answer this question.
//
// https://stackoverflow.com/questions/4165131/c-c-switch-for-non-integers
//
// It is based on the StackOverflow question:
// https://stackoverflow.com/questions/2111667/compile-time-string-hashing
//
// And the solution
// https://stackoverflow.com/questions/2111667/compile-time-string-hashing/23683218#23683218
//

#include <iostream>
#include <string>
#include <vector>
namespace detail {

// CRC32 Table (zlib polynomial)
static constexpr uint32_t crc_table[256] =
{
    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
    0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
    0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
    0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
    0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
    0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
    0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
    0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
    0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
    0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
    0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
    0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
    0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
    0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
    0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
    0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
    0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
    0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};

//constexpr combine
template<size_t idx>
constexpr uint32_t combine_crc32(const char * str, uint32_t part) {
  return (part >> 8) ^ crc_table[(part ^ str[idx]) & 0x000000FF];
}

//constexpr driver
template<size_t idx>
constexpr uint32_t crc32(const char * str) {
  return combine_crc32<idx>(str, crc32<idx - 1>(str));
}

//constexpr recursion stopper
template<>
constexpr uint32_t crc32<size_t(-1)>(const char * str) {
  return 0xFFFFFFFF;
}

//runtime combine
uint32_t combine_crc32_s(size_t idx, const char * str, uint32_t part) {
  return (part >> 8) ^ crc_table[(part ^ str[idx]) & 0x000000FF];
}

//runtime driver
uint32_t crc32_s(size_t idx, const char * str) {
  if( idx==static_cast<size_t>(-1) )return 0xFFFFFFFF;
  return combine_crc32_s(idx, str, crc32_s(idx-1,str));
}

} //namespace detail

//constexpr that returns unsigned int
template <size_t len>
constexpr uint32_t uint_crc32(const char (&str)[len]) {
  return detail::crc32<len - 2>(str) ^ 0xFFFFFFFF;
}

//constexpr that returns signed int
template <size_t len>
constexpr int int_crc32(const char (&str)[len]) {
  return static_cast<int>( uint_crc32(str) );
}

//runtime that returns unsigned int
uint32_t uint_crc32_s( const char* str ) {
  return detail::crc32_s(strlen(str)-1,str) ^ 0xFFFFFFFF;
}

//runtime that returns signed int
int int_crc32_s( const char* str) {
  return static_cast<int>( uint_crc32_s(str) );
}

//convenient macros
#define S_SWITCH( X ) const char* SWITCH_KEY(X.c_str()); switch( int_crc32_s(X.c_str()) )
#define S_CASE( X ) case int_crc32(X): if( strcmp(SWITCH_KEY,X) ){ goto S_DEFAULT_LABEL;}
#define S_DEFAULT S_DEFAULT_LABEL: default:

int main()
{
    std::string str;
    std::cin >> str;

    //two strings that yield same crc32
    const char* collision1="DeferredAmbient_6_1_18-1of2_5";
    const char* collision2="PostEffect_Lighting_18_6-0of1_8_14_13-1of2_19";

    //without macros (you need to check
    switch( int_crc32_s(str.c_str()) )
    {
        case int_crc32("foo"): if( str=="foo"){std::cout << "foo you\n"; break;}
        case int_crc32("bar"): if( str=="bar"){std::cout << "bar you\n"; break;}
        case int_crc32("baz"): if( str=="baz"){std::cout << "baz you\n"; break;}
        case int_crc32("PostEffect_Lighting_18_6-0of1_8_14_13-1of2_19"):
            if( str=="PostEffect_Lighting_18_6-0of1_8_14_13-1of2_19"){
                std::cout << "jackpot!\n"; break;
            }
        default: std::cout << "just you\n";
    }

    //with macros
    S_SWITCH( str )
    {
        S_CASE("foo"){ std::cout << "foo you\n"; break; }
        S_CASE("bar"){ std::cout << "bar you\n"; break; }
        S_CASE("baz"){ std::cout << "baz you\n"; break; }
        S_CASE("PostEffect_Lighting_18_6-0of1_8_14_13-1of2_19"){ std::cout << "jackpot!\n"; break; }
        S_DEFAULT{ std::cout << "just you\n"; }
    }
}

Answer 17

此答案是https://stackoverflow.com/a/4165312/10075467针对同一问题的答案smilingthax的一项补充工作，其中修改了Switch函数以获取结果，而无需实际排序（目的是通过map实现相反，复杂度仍然会受到影响。）

#include "iostream"
#include "algorithm"
#include "cstring"
#include "map"
#include "typeinfo"

using namespace std;

template <class key_t, class val_fn>
void Switch(const key_t switch_key, auto switch_cases, val_fn default_case = []{printf("not found\n");} )
{
    //using key_value_pair = pair<const key_t, val_fn>;
    for(auto x : switch_cases) { cout<<x.first<<" : "; x.second(); cout<<"\t"; } cout<<endl;
    auto match = switch_cases.find(switch_key);
    if(match == switch_cases.end()) { default_case(); return; }
    match -> second();
    //cout<<typeid(switch_cases).name();
}

int main()
{
    string switch_key = " 6ZG ";
    //getline(cin, switch_key);
    map <string, void (*)()> switch_cases = {
            { "gef", []{ printf("0\n"); } },
            { "hde", []{ printf("1\n"); } },
            { "ger", []{ printf("2\n"); } },
            { "aTe", []{ printf("0\n"); } },
            { "ymX", []{ printf("1\n"); } },
            { "zcx", []{ printf("16\n"); } },
            { "i5B", []{ printf("17\n"); } },
            { "5ui", []{ printf("18\n"); } },
            { "zkB", []{ printf("19\n"); } },
            { " zxw ", []{ printf(" 0 \n"); } },
            { " Aq0 ", []{ printf(" 1 \n"); } },
            { " uSa ", []{ printf(" 2 \n"); } },
            { " 3pY ", []{ printf(" 3 \n"); } },
            { " 6ZG ", []{ printf(" 4 \n"); } },
            { " PHT ", []{ printf(" 5 \n"); } },
            { " Jv9 ", []{ printf(" 6 \n"); } },
            { " 0NQ ", []{ printf(" 7 \n"); } },
            { " 4Ys ", []{ printf(" 8 \n"); } },
            { " GzK ", []{ printf(" 9 \n"); } }
        };
    Switch<string, void (*)()> ( switch_key, switch_cases);//, [](const string a, string b){ return a!=b;} );

    return 0;
}

让地图为我们做分类工作。如果我们已经有一个switch_cases列表，那么最好再使用initializer_list。

编辑：最近，我codechef submission中的一个人对laddus使用了同样的方法。在这里，我用它来返回整数类型而不是void。

C / C ++：切换非整数

17 个答案:

更新C ++ 11：

2016年更新：编译时间trie

功能

哈希去胜利

没有宏

使用宏

完整实施[gist]