C / C ++:切换为非整数

通常我需要根据非POD常量元素的值来select做什么,如下所示:

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

可悲的switch只能用于整数: error: switch quantity not an integer

实现这种事情的最微不足道的方法就是一系列if s:

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

但是这个解决scheme看起来很脏,并且应该花费O(n),其中n是个案数量,而那个代码在二进制search的情况下可能在最坏的情况下花费O(log n)。

使用一些数据结构(如地图),可以获得一个表示string(O(log n))的整数,然后使用O(1) switch ,或者可以通过嵌套实现静态二进制sorting, if s in正确的方式,但这些黑客仍然需要大量的编码,使一切变得更加复杂和难以维护。

什么是最好的方法来做到这一点? (快速,干净和简单,因为switch语句是)

使用一些令人讨厌的macros和模板魔法,可以在编译时使用漂亮的语法来获得展开的二进制search – 但MATCHES(“case”)必须被sorting : 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是隐含的,你不能掉以轻心。 这也没有大量logging,对不起。 但是你会发现,有更多的使用可能性,看看。 注意:只能用g ++进行testing。

更新C ++ 11:

Lambda和初始化列表使事情变得更漂亮(不涉及macros):

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

这是主意。 更完整的实现可以在这里find: switch.hpp 。

更新2016年:编译时间特里

我最新的这个问题是在编译时使用高级的c ++ 11元编程来生成一个search-trie 。 不像以前的方法,这将处理未分类的案例分支/string就好了; 他们只需要string。 G ++也允许使用constexpr,但不能使用clang(如HEAD 3.9.0 / trunk 274233)。

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

完整的实现可以在github上find: smilingthax / cttrie 。

在C ++中,通过使用std::map<std::string, functionPointerType>可以获得O(lg n)性能。 (在C中,你可以实现本质上相同的东西,但是会更困难)使用std::map<k, v>::find ,并且调用那个指针来取出正确的函数指针。 当然,这不会像语言支持的switch语句那么简单。 另一方面,如果你有足够的项目,那么O(n)O(lg n)之间会有很大的差别,这可能表明你应该首先去做一个不同的devise。

就我个人而言,我始终发现ELSEIF链的可读性更强。

你可以在不使用任何map或unordered_map的情况下实现它,如下所示。 单独比较第一个字符来确定哪个string。 如果多于一个匹配,那么可以在该case语句内回退到if / else链。 如果没有多个以相同字母开头的string,比较次数将大大减less。

 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 } } 

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

使用if...else block 。 你真的没有一个令人信服的理由,除了看起来不漂亮之外, if...else块是最简单的解决scheme。

其他一切都需要额外的代码,这样会增加复杂性。 它只是把丑陋的行为转移到其他地方。 但是在某种程度上,一个string比较还是必须要发生的。 现在你已经用更多的代码覆盖了它。

通过使用地图或哈希映射,您可能会获得一些性能提升,但通过简单地select一个巧妙的顺序来评估您的if...else块,您也可以获得类似(如果不是更好的)增益。 而出于性能原因切换到地图实际上只是过早的微观优化。

在C中,有两个常见的解决scheme。 首先是保持你的关键字在一个有序的数组中,比方说

 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 }, ... }; 

并对它们进行二分search 。 以前是C大师Brian W. Kernighan的awk的源代码。

如果n是inputstring的长度,而m是最长关键字的长度,则另一种解决scheme是O (min( mn )),即使用Lex程序等有限状态解决scheme。

像这样的东西太复杂了?

 #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" } 

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

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

以下是可用的示例代码:

这应该工作。
(但仅限于4字节或更less的string)

这将string视为4字节整数。

这被认为是丑陋,不便携,“哈克”,并没有一个很好的风格。 但它确实做你想要的。

 #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中testing

在我看来,这是一个基于元编程的哈希生成器,你可以在这个例子中使用 。 这是一个C ++ 0x,但我相信你可以重现它类似的标准C ++。

你仍然可以使用开关..如果你事先知道标签..(这是相当讨厌的(即没有检查,但只要你有一个有效的空终止的string应该是微不足道的!),我应该想象这比大多数选项执行速度更快?

 //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 } } } 

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

您可以使用我的开关macros ,它支持所有types的值。 在less数情况下,连续几次使用op==比每次创build映射的速度都要快,并且在其中查找。

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

您可以使用任何types的c / c ++ 切换实现 。 你的代码将是这样的:

 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" 

可以使用更复杂的types,例如std::pairs或任何支持相等操作的结构或类(或快速模式的同名)。

特征

  • 任何支持比较或检查相等的数据types
  • build立级联嵌套开关状态的可能性。
  • 可能性通过案例陈述来破坏或破坏
  • 可能性使用非constatnt caseexpression式
  • 可以使用树search来启用快速静态/dynamic模式(对于C ++ 11)

Sintax与语言切换的区别在于

  • 大写关键字
  • CASE语句需要括号
  • 分号“;” 在声明的结尾是不允许的
  • 冒号':'CASE语句是不允许的
  • 在CASE语句结束时需要BREAK或FALL关键字之一

对于C++97语言使用线性search。 对于C++11和更现代的可能使用quick模式的Wuth树search,CASE中的返回语句变得不被允许。 C语言实现存在于使用char*types和零终止string比较的地方。

阅读更多关于这个开关实现。

请注意,通过const char *进行切换不会像预期的那样工作,即使它被允许。

ACstring实际上是一个指向char的指针。 像你这样的代码build议:

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

如果我们的语言是一致的 – 它会比较指针值 ,而不是实际的string内容。 比较string需要一个strcmp() ,所以即使编译器有一个像“如果我们切换到char* ”的特殊情况,使用strcmp()而不是== (反正这可能是糟糕的语言devise)编译器不可能像O(1)那样用整数和跳转来完成这个工作。

所以不要为C / C ++感到不舒服,因为它不被支持。 🙂

如果你觉得你需要可伸缩性,我推荐使用map (string -> funcptr)(string -> some abstract object)的O(logn)解决scheme。 如果你不这样做,O(n)解决scheme和其他if都没有什么特别的错误。 它仍然是清晰的,可维护的代码,所以没有什么可感觉不好的。

前一段时间,我写了一个模板类,实现了某种types的开关,可用于任何数据types 。 但是,有一些限制它的应用领域的限制:

  • 在每个分支上实现的任务必须是一个函数调用。
  • 要调用的函数有一个参数(或者没有,或者两个,你可以调整模板,但是对于所有的函数必须是相同的)。
  • 传递给函数的参数值在每种情况下都是相同的(但是在执行切换的时候给出)。

举例来说,如果要打开MyTypetypes的值,如果它等于value1 ,则调用function1("abc") ,如果它等于value2 ,则调用function2("abc") (依此类推)。 这将最终成为:

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

基本上,它包装一个std :: map容器,保存pair值/函数。 它也可以处理“默认”,这使得切换如此有趣。 它可以很容易地适应其他情况。 这里是代码:

 template < typename KEY, typename FUNC, typename ARG > class SWITCH { public: SWITCH() { Def = 0; // no default function at startup } void Process( const KEY& key, ARG arg ) { typename std::map< KEY, FUNC >::const_iterator it = my_map.find( key ); if( it != my_map.end() ) // If key exists, call it->second( arg ); // associated function else // else, call if( Def ) // default function, if there is one. Def( arg ); // else, do nothing } void Add( const KEY& key, FUNC my_func ) { typename std::map< KEY, FUNC >::const_iterator it = my_map.find( key ); if( it != my_map.end() ) { throw "Already defined !\n"; } my_map[ key ] = my_func; } void AddDefault( FUNC f ) { Def = f; } private: std::map< KEY, FUNC > my_map; FUNC Def; // default function }; 

其他细节在这里 。

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

这里的主要胜利在于,由于散列冲突而不存在任何问题:无论如何,在接受一个案例之前总是比较实际的string。

哈希你的方式胜利

你可以使用像这个辉煌的堆栈溢出答案一样的编译时散列函数。 如果你创build的function

  • int_crc32_s在运行时和返回一个string的散列
  • int_crc32在编译时返回一个string的散列

你被设置。 要处理关键string和大小写string的crc的错误匹配,您需要包含明确的匹配检查。 这并不影响性能,因为它只是一个单一的检查,但它使得它更加丑陋,macros观版本看起来更好。

我发现这两个string具有相同的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"; 

没有macros

 //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"; } 

与macros

 //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"; } } 

全面实施[主要]

 // 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/cc-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"; } } }