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（ m ， n ）），即使用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"; } } }
