entityMap|blocks|key|c2ome|text|无论如何，编译器都会对其进行优化--使用开关，因为它是最具可读性的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

Compiler will optimise it anyway - go for the switch as it's the most readable.

entityMap|blocks|key|e7ma|text|开关，如果只是为了可读性。在我看来，巨大的if语句更难维护，也更难阅读。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|74r5j|错误|c664d|_|4v6v0|01|4ons3|：//故意漏洞百出|ch4cf|或者|f4ebv|(错误|2pr1f|dpln9|01+==+numError)+%7C%7C|6v7ei|后者比第一个更容易出错，并且需要更多的键入和格式化。^0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|T|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|U|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|V|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|W|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|X|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|Y|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|Z|9|@]|A|@]|B|$]]|$2|O|4|F|6|7|8|10|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|11|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|12|9|@]|A|@]|B|$]]]]

The Switch, if only for readability. Giant if statements are harder to maintain and harder to read in my opinion. 

ERROR_01 : // intentional fall-through

or 

(ERROR_01 == numError) ||

The later is more error prone and requires more typing and formatting than the first.

entityMap|blocks|key|btr2q|text|我不太确定最佳实践，但我会使用switch，然后通过'default‘诱使故意出错。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

I'm not sure about best-practise, but I'd use switch - and then trap intentional fall-through via 'default'

entityMap|blocks|key|6gpb3|text|IMO这是一个完美的例子，说明了交换机跌倒是为了什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

IMO this is a perfect example of what switch fall-through was made for.

entityMap|blocks|key|8uo1n|text|为了清晰和约定，我会选择if语句，尽管我相信有些人不会同意。毕竟，你是想要做一些事情|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1gfuq|某些条件是真的！一个动作的开关看起来有点...没有必要。^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

I would pick the if statement for the sake of clarity and convention, although I'm sure that some would disagree. After all, you are wanting to do something <code>if</code> some condition is true! Having a switch with one action seems a little... unneccesary.

entityMap|blocks|key|8pn8s|text|如果您的案例将来可能保持分组状态--如果多个案例对应一个结果--那么开关可能更易于阅读和维护。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

If your cases are likely to remain grouped in the future--if more than one case corresponds to one result--the switch may prove to be easier to read and maintain.

entityMap|blocks|key|65vst|text|我不是告诉你速度和内存使用的人，但是看一个switch语句比一个大的if语句更容易理解(特别是2-3个月以后)|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

Im not the person to tell you about speed and memory usage, but looking at a switch statment is a hell of a lot easier to understand then a large if statement (especially 2-3 months down the line)

entityMap|blocks|key|2vvjc|text|使用开关。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|bjdo9|在最坏的情况下，编译器将生成与if-else链相同的代码，因此您不会丢失任何内容。如果有疑问，请将最常见的情况放在switch语句中。|2f67g|在最好的情况下，优化器可能会找到一种更好的方法来生成代码。编译器通常做的事情是构建一个二进制决策树(在平均情况下保存比较和跳转)，或者简单地构建一个跳转表(工作时根本不需要比较)。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|G|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|H|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|I|9|@]|A|@]|B|$]]]]

Use switch.

In the worst case the compiler will generate the same code as a if-else chain, so you don't lose anything. If in doubt put the most common cases first into the switch statement.

In the best case the optimizer may find a better way to generate the code. Common things a compiler does is to build a binary decision tree (saves compares and jumps in the average case) or simply build a jump-table (works without compares at all).

entityMap|blocks|key|dk7bh|text|它们同样工作得很好。现代编译器的性能与之相当。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|anfbp|与case语句相比，我更喜欢if语句，因为它们更具可读性，也更灵活--您可以添加其他不基于数值相等的条件，比如“%7C%7C+max+<+min”。但是对于你在这里发布的简单案例，这并不重要，只要做你最容易读的就行了。^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|E|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|F|9|@]|A|@]|B|$]]]]

They work equally well. Performance is about the same given a modern compiler.

I prefer if statements over case statements because they are more readable, and more flexible -- you can add other conditions not based on numeric equality, like " || max &lt; min ". But for the simple case you posted here, it doesn't really matter, just do what's most readable to you.

entityMap|blocks|key|8slv3|text|switch绝对是首选。查看开关的用例列表&确切地知道它在做什么要比阅读长长的if条件容易得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|41c8s|中的重复|2q1q1|情况对眼睛很不利。假设其中一个|6godd|已经写好了|3ej0q|；你会注意到吗？或者如果'numError‘的一个实例被写成'nmuError'，那么它是不是恰好被编译了？|pj28|我通常更喜欢使用多态性而不是switch，但是如果没有更多的上下文细节，就很难说了。|9rpqs|至于性能，最好的办法是使用分析器在与您期望的条件相似的条件下测量应用程序的性能。否则，您可能在错误的地方以错误的方式进行优化。^0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|O|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|P|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|Q|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|R|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|S|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|T|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|U|9|@]|A|@]|B|$]]]]

switch is definitely preferred. It's easier to look at a switch's list of cases &amp; know for sure what it is doing than to read the long if condition. 

The duplication in the <code>if</code> condition is hard on the eyes. Suppose one of the <code>==</code> was written <code>!=</code>; would you notice? Or if one instance of 'numError' was written 'nmuError', which just happened to compile?

I'd generally prefer to use polymorphism instead of the switch, but without more details of the context, it's hard to say.

As for performance, your best bet is to use a profiler to measure the performance of your application in conditions that are similar to what you expect in the wild. Otherwise, you're probably optimizing in the wrong place and in the wrong way.

entityMap|blocks|key|cpn2|text|我会说使用开关。这样你只需要实现不同的结果。您的十个相同的案例可以使用默认值。如果一次更改，您所需做的就是显式地实现更改，不需要编辑默认值。与编辑IF和ELSEIF相比，在开关中添加或删除大小写也要容易得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|97eqd|switch(numerror){
++++ERROR_20+:+{+fire_special_event();+}+break;
++++default+:+{+null;+}+break;
}|code-block|syntax|javascript|v13o|也许甚至可以针对一系列可能性测试您的条件(在本例中为numerror)，可能是一个数组，因此您的开关甚至不会被使用，除非确实会有一个结果。^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|K|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$]]]]

I would say use SWITCH. This way you only have to implement differing outcomes. Your ten identical cases can use the default. Should one change all you need to is explicitly implement the change, no need to edit the default. It's also far easier to add or remove cases from a SWITCH than to edit IF and ELSEIF.

<pre><code>switch(numerror){
 ERROR_20 : { fire_special_event(); } break;
 default : { null; } break;
}
</code></pre>

Maybe even test your condition (in this case numerror) against a list of possibilities, an array perhaps so your SWITCH isn't even used unless there definately will be an outcome.

entityMap|blocks|key|amjh2|text|我同意switch解决方案的简洁性，但我相信您|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3kptn|劫持交换机|uq4s|给你。|dk2pp|交换机的用途是|dovms|不同|1q9bu|根据值进行处理。|9msnp|如果你必须用伪代码来解释你的算法，你会使用一个If，因为从语义上讲，它就是：|5k96u|如果是这样的话|4olc4|_|ein68|执行此操作时出错|32st1|..。|cekvl|因此，除非您打算在某一天更改代码，使每个错误都有特定的代码，否则我将使用|b3vls|如果|66ei1^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|11|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|12|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|13|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|14|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|15|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|16|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|17|9|@]|A|@]|B|$]]|$2|O|4|P|6|7|8|18|9|@]|A|@]|B|$]]|$2|Q|4|R|6|7|8|19|9|@]|A|@]|B|$]]|$2|S|4|T|6|7|8|1A|9|@]|A|@]|B|$]]|$2|U|4|V|6|7|8|1B|9|@]|A|@]|B|$]]|$2|W|4|X|6|7|8|1C|9|@]|A|@]|B|$]]|$2|Y|4|Z|6|7|8|1D|9|@]|A|@]|B|$]]|$2|10|4|V|6|7|8|1E|9|@]|A|@]|B|$]]]]

I agree with the compacity of the switch solution but IMO you're hijacking the switch here. 
The purpose of the switch is to have different handling depending on the value. 
If you had to explain your algo in pseudo-code, you'd use an if because, semantically, that's what it is: if whatever_error do this... 
So unless you intend someday to change your code to have specific code for each error, I would use if.

entityMap|blocks|key|5ib1r|text|考虑到你只有30个错误代码，编写你自己的跳转表，然后你自己做出所有的优化选择(跳转总是最快的)，而不是希望编译器做正确的事情。它还使得代码非常小(除了跳转表的静态声明)。它还有一个附带的好处，即使用调试器，您可以在运行时根据需要修改行为，只需直接拨动表数据即可。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

Seeing as you only have 30 error codes, code up your own jump table, then you make all optimisation choices yourself (jump will always be quickest), rather than hope the compiler will do the right thing. It also makes the code very small (apart from the static declaration of the jump table). It also has the side benefit that with a debugger you can modify the behaviour at runtime should you so need, just by poking the table data directly.

entityMap|blocks|key|6gier|text|交换机|type|unstyled|depth|inlineStyleRanges|entityRanges|data|7849h|是|efolo|快点。|1cd7q|只需尝试if/else-ing一个循环中的30个不同的值，并使用switch将其与相同的代码进行比较，看看switch的速度有多快。|ubs1|现在，|907s|交换机有一个真正的问题|7fark|：开关必须在编译时知道每个case中的值。这意味着以下代码：|ara2t|//+WON'T+COMPILE
extern+const+int+MY_VALUE+;

void+doSomething(const+int+p_iValue)
{
++++switch(p_iValue)
++++{
+++++++case+MY_VALUE+:+/*+do+something+*/+;+break+;
+++++++default+:+/*+do+something+else+*/+;+break+;
++++}
}|code-block|syntax|javascript|l2kk|不会编译。|b084f|然后，大多数人将使用定义(啊！)，其他人将在同一编译单元中声明和定义常量变量。例如：|bojlg|//+WILL+COMPILE
const+int+MY_VALUE+=+25+;

void+doSomething(const+int+p_iValue)
{
++++switch(p_iValue)
++++{
+++++++case+MY_VALUE+:+/*+do+something+*/+;+break+;
+++++++default+:+/*+do+something+else+*/+;+break+;
++++}
}|dlgv1|因此，最终，开发人员必须在“速度%2B清晰度”和“代码耦合”之间做出选择。|ee02t|(并不是说开关不能写成像地狱一样令人困惑……我目前看到的大多数开关都属于这种“令人困惑的”类别……但这是另一回事……)|1kuu2|5sgma|编辑2008-09-21：|3skjj|b9sr5|ahors|bk1e|53ber|添加了以下评论：“|euein|在头文件中将常量定义为枚举是处理此问题的另一种方式。|fhdmk|6qrsi|当然是这样的。|9g0ct|外部类型的要点是将值与源分离。将该值定义为宏、简单的const+int声明，甚至是枚举，都会产生内联值的副作用。因此，如果定义、枚举值或常量int值发生更改，则需要重新编译。外部声明意味着在值改变的情况下不需要重新编译，但另一方面，使它不可能使用开关。结论是|84lva|使用switch将增加switch代码和用作case的变量之间的耦合。|c115i|..。当它是Ok的时候，然后使用开关。那么，当它不是的时候，也就不足为奇了。|cjltp|4dig4|..。|1gne7|9ag6a|编辑2013-01-15：|cmqqd|gm19|41ura|弗拉德·拉扎连科|5fmao|评论了我的回答，给出了一个链接，指向他对开关生成的汇编代码的深入研究。非常闪电：|5ebqf|http://lazarenko.me/switch/^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|21|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|22|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|23|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|24|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|25|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|26|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|27|9|@]|A|@]|B|$]]|$2|O|4|P|6|Q|8|28|9|@]|A|@]|B|$R|S]]|$2|T|4|U|6|7|8|29|9|@]|A|@]|B|$]]|$2|V|4|W|6|7|8|2A|9|@]|A|@]|B|$]]|$2|X|4|Y|6|Q|8|2B|9|@]|A|@]|B|$R|S]]|$2|Z|4|10|6|7|8|2C|9|@]|A|@]|B|$]]|$2|11|4|12|6|7|8|2D|9|@]|A|@]|B|$]]|$2|13|4|-4|6|7|8|2E|9|@]|A|@]|B|$]]|$2|14|4|15|6|7|8|2F|9|@]|A|@]|B|$]]|$2|16|4|-4|6|7|8|2G|9|@]|A|@]|B|$]]|$2|17|4|-4|6|7|8|2H|9|@]|A|@]|B|$]]|$2|18|4|19|6|7|8|2I|9|@]|A|@]|B|$]]|$2|1A|4|1B|6|7|8|2J|9|@]|A|@]|B|$]]|$2|1C|4|1D|6|7|8|2K|9|@]|A|@]|B|$]]|$2|1E|4|-4|6|7|8|2L|9|@]|A|@]|B|$]]|$2|1F|4|1G|6|7|8|2M|9|@]|A|@]|B|$]]|$2|1H|4|1I|6|7|8|2N|9|@]|A|@]|B|$]]|$2|1J|4|1K|6|7|8|2O|9|@]|A|@]|B|$]]|$2|1L|4|1M|6|7|8|2P|9|@]|A|@]|B|$]]|$2|1N|4|-4|6|7|8|2Q|9|@]|A|@]|B|$]]|$2|1O|4|1P|6|7|8|2R|9|@]|A|@]|B|$]]|$2|1Q|4|-4|6|7|8|2S|9|@]|A|@]|B|$]]|$2|1R|4|1S|6|7|8|2T|9|@]|A|@]|B|$]]|$2|1T|4|-4|6|7|8|2U|9|@]|A|@]|B|$]]|$2|1U|4|-4|6|7|8|2V|9|@]|A|@]|B|$]]|$2|1V|4|1W|6|7|8|2W|9|@]|A|@]|B|$]]|$2|1X|4|1Y|6|7|8|2X|9|@]|A|@]|B|$]]|$2|1Z|4|20|6|7|8|2Y|9|@]|A|@]|B|$]]]]

The switch is faster.

Just try if/else-ing 30 different values inside a loop, and compare it to the same code using switch to see how much faster the switch is.

Now, the switch has one real problem : The switch must know at compile time the values inside each case. This means that the following code:

<pre><code>// WON'T COMPILE
extern const int MY_VALUE ;

void doSomething(const int p_iValue)
{
 switch(p_iValue)
 {
 case MY_VALUE : /* do something */ ; break ;
 default : /* do something else */ ; break ;
 }
}
</code></pre>

won't compile.

Most people will then use defines (Aargh!), and others will declare and define constant variables in the same compilation unit. For example:

<pre><code>// WILL COMPILE
const int MY_VALUE = 25 ;

void doSomething(const int p_iValue)
{
 switch(p_iValue)
 {
 case MY_VALUE : /* do something */ ; break ;
 default : /* do something else */ ; break ;
 }
}
</code></pre>

So, in the end, the developper must choose between "speed + clarity" vs. "code coupling".

(Not that a switch can't be written to be confusing as hell... Most the switch I currently see are of this "confusing" category"... But this is another story...)

<blockquote>
 Edit 2008-09-21:
 
 <a href="https://stackoverflow.com/users/8090/bk1e">bk1e</a> added the following comment: "Defining constants as enums in a header file is another way to handle this".
 
 Of course it is.
 
 The point of an extern type was to decouple the value from the source. Defining this value as a macro, as a simple const int declaration, or even as an enum has the side-effect of inlining the value. Thus, should the define, the enum value, or the const int value change, a recompilation would be needed. The extern declaration means the there is no need to recompile in case of value change, but in the other hand, makes it impossible to use switch. The conclusion being Using switch will increase coupling between the switch code and the variables used as cases. When it is Ok, then use switch. When it isn't, then, no surprise.
</blockquote>

.

<blockquote>
 Edit 2013-01-15:
 
 <a href="https://stackoverflow.com/users/405725/vlad-lazarenko">Vlad Lazarenko</a> commented on my answer, giving a link to his in-depth study of the assembly code generated by a switch. Very enlightning: <a href="http://lazarenko.me/switch/" rel="noreferrer">http://lazarenko.me/switch/</a>
</blockquote>

entityMap|blocks|key|47t04|text|代码的可读性。如果您想知道哪些性能更好，请使用分析器，因为优化和编译器各不相同，性能问题很少出现在人们认为的地方。|type|unstyled|depth|inlineStyleRanges|entityRanges|data^0^^$0|$]|1|@$2|3|4|5|6|7|8|C|9|@]|A|@]|B|$]]]]

Code for readability. If you want to know what performs better, use a profiler, as optimizations and compilers vary, and performance issues are rarely where people think they are.

entityMap|blocks|key|45lg9|text|对于您在示例中提供的特殊情况，最清晰的代码可能是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|r61f|if+(RequiresSpecialEvent(numError))
++++fire_special_event();|code-block|syntax|javascript|831le|显然，这只是将问题转移到代码的不同区域，但现在您有机会重用此测试。对于如何解决它，您也有更多的选择。您可以使用std::set，例如：|3b4q2|bool+RequiresSpecialEvent(int+numError)
{
++++return+specialSet.find(numError)+!=+specialSet.end();
}|96ue|我并不是说这是RequiresSpecialEvent的最佳实现，只是说它是一种选择。您仍然可以使用switch或if-else链，或者查找表，或者对值进行一些位操作。你的决策过程变得越模糊，你从一个孤立的函数中获得的价值就越大。^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|N|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|O|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|P|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|Q|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|R|9|@]|A|@]|B|$]]]]

For the special case that you've provided in your example, the clearest code is probably:

<pre><code>if (RequiresSpecialEvent(numError))
 fire_special_event();
</code></pre>

Obviously this just moves the problem to a different area of the code, but now you have the opportunity to reuse this test. You also have more options for how to solve it. You could use std::set, for example:

<pre><code>bool RequiresSpecialEvent(int numError)
{
 return specialSet.find(numError) != specialSet.end();
}
</code></pre>

I'm not suggesting that this is the best implementation of RequiresSpecialEvent, just that it's an option. You can still use a switch or if-else chain, or a lookup table, or some bit-manipulation on the value, whatever. The more obscure your decision process becomes, the more value you'll derive from having it in an isolated function.

entityMap|blocks|key|5ts7v|text|从美学上讲，我倾向于使用这种方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|7mp8n|unsigned+int+special_events[]+=+{
++++ERROR_01,
++++ERROR_07,
++++ERROR_0A,
++++ERROR_10,
++++ERROR_15,
++++ERROR_16,
++++ERROR_20
+};
+int+special_events_length+=+sizeof+(special_events)+/+sizeof+(unsigned+int);

+void+process_event(unsigned+int+numError)+{
+++++for+(int+i+=+0;+i+<+special_events_length;+i%2B%2B)+{
+++++++++if+(numError+==+special_events[i])+{
+++++++++++++fire_special_event();
+++++++++++++break;
++++++++++}
+++++}
++}|code-block|syntax|javascript|2pkel|让数据变得更智能一点，这样我们就可以让逻辑变得更愚蠢一些。|fa5rs|我知道这看起来很奇怪。以下是我的灵感(来自我在Python中的做法)：|1dg4l|special_events+=+[
++++ERROR_01,
++++ERROR_07,
++++ERROR_0A,
++++ERROR_10,
++++ERROR_15,
++++ERROR_16,
++++ERROR_20,
++++]
def+process_event(numError):
++++if+numError+in+special_events:
+++++++++fire_special_event()^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|N|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|O|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|P|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|Q|9|@]|A|@]|B|$]]|$2|L|4|M|6|E|8|R|9|@]|A|@]|B|$F|G]]]]

Aesthetically I tend to favor this approach.

<pre><code>unsigned int special_events[] = {
 ERROR_01,
 ERROR_07,
 ERROR_0A,
 ERROR_10,
 ERROR_15,
 ERROR_16,
 ERROR_20
 };
 int special_events_length = sizeof (special_events) / sizeof (unsigned int);

 void process_event(unsigned int numError) {
 for (int i = 0; i &lt; special_events_length; i++) {
 if (numError == special_events[i]) {
 fire_special_event();
 break;
 }
 }
 }
</code></pre>

Make the data a little smarter so we can make the logic a little dumber.

I realize it looks weird. Here's the inspiration (from how I'd do it in Python):

<pre><code>special_events = [
 ERROR_01,
 ERROR_07,
 ERROR_0A,
 ERROR_10,
 ERROR_15,
 ERROR_16,
 ERROR_20,
 ]
def process_event(numError):
 if numError in special_events:
 fire_special_event()
</code></pre>

entityMap|blocks|key|annf4|text|使用switch，这是它的用途，也是程序员所期望的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|igdv|不过，我会把多余的案例标签放进去--只是为了让人们感到舒服，我试图记住什么时候/什么规则可以把它们去掉。|2aljm|您不希望下一位开发它的程序员不得不为语言细节做任何不必要的思考(几个月后可能就是您了！)^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|G|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|H|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|I|9|@]|A|@]|B|$]]]]

Use switch, it is what it's for and what programmers expect.

I would put the redundant case labels in though - just to make people feel comfortable, I was trying to remember when / what the rules are for leaving them out. 
You don't want the next programmer working on it to have to do any unnecessary thinking about language details (it might be you in a few months time!)

entityMap|blocks|key|6gesd|text|我知道它很古老，但是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3hfpm|public+class+SwitchTest+{
static+final+int+max+=+100000;

public+static+void+main(String[]+args)+{

int+counter1+=+0;
long+start1+=+0l;
long+total1+=+0l;

int+counter2+=+0;
long+start2+=+0l;
long+total2+=+0l;
boolean+loop+=+true;

start1+=+System.currentTimeMillis();
while+(true)+{
++if+(counter1+==+max)+{
++++break;
++}+else+{
++++counter1%2B%2B;
++}
}
total1+=+System.currentTimeMillis()+-+start1;

start2+=+System.currentTimeMillis();
while+(loop)+{
++switch+(counter2)+{
++++case+max:
++++++loop+=+false;
++++++break;
++++default:
++++++counter2%2B%2B;
++}
}
total2+=+System.currentTimeMillis()+-+start2;

System.out.println("While+if/else:+"+%2B+total1+%2B+"ms");
System.out.println("Switch:+"+%2B+total2+%2B+"ms");
System.out.println("Max+Loops:+"+%2B+max);

System.exit(0);
}
}|code-block|syntax|javascript|dbbdt|改变循环计数会有很大的变化：|2tgoj|if/else:+5毫秒开关:1毫秒最大环路数:+100000|adfpg|if/else:+5ms开关:+3ms最大环路数:+1000000|62l8a|if/else:+5毫秒开关:14毫秒最大环路数:+10000000|d6ijf|if/else:+5毫秒开关:149毫秒最大环路数:+100000000|4ghl0|(如果需要，可以添加更多语句)^0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|T|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|U|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|V|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|W|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|X|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|Y|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|Z|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|10|9|@]|A|@]|B|$]]]]

I know its old but

<pre><code>public class SwitchTest {
static final int max = 100000;

public static void main(String[] args) {

int counter1 = 0;
long start1 = 0l;
long total1 = 0l;

int counter2 = 0;
long start2 = 0l;
long total2 = 0l;
boolean loop = true;

start1 = System.currentTimeMillis();
while (true) {
 if (counter1 == max) {
 break;
 } else {
 counter1++;
 }
}
total1 = System.currentTimeMillis() - start1;

start2 = System.currentTimeMillis();
while (loop) {
 switch (counter2) {
 case max:
 loop = false;
 break;
 default:
 counter2++;
 }
}
total2 = System.currentTimeMillis() - start2;

System.out.println("While if/else: " + total1 + "ms");
System.out.println("Switch: " + total2 + "ms");
System.out.println("Max Loops: " + max);

System.exit(0);
}
}
</code></pre>

Varying the loop count changes a lot: 

While if/else: 5ms
Switch: 1ms
Max Loops: 100000

While if/else: 5ms
Switch: 3ms
Max Loops: 1000000

While if/else: 5ms
Switch: 14ms
Max Loops: 10000000

While if/else: 5ms
Switch: 149ms
Max Loops: 100000000

(add more statements if you want)

entityMap|blocks|key|9o284|text|while+(true)+!=+while+(loop)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|8ndd1|可能第一个循环是由编译器优化的，这就解释了为什么第二个循环在增加循环数量时会变慢。|unstyled^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$C|D]]|$2|E|4|F|6|G|8|I|9|@]|A|@]|B|$]]]]

<pre><code>while (true) != while (loop)
</code></pre>

Probably the first one is optimised by the compiler, that would explain why the second loop is slower when increasing loop count.

entityMap|blocks|key|c639n|text|编译器真的很擅长优化|type|unstyled|depth|inlineStyleRanges|entityRanges|data|fqs2j|..。最近的gcc也擅长在|87au5|..。|6mtv0|我在上面做了一些测试用例|6djia|godbolt|6mpps|vktn|当|al1ri|值被紧密地分组在一起，gcc、clang和icc都足够智能，可以使用位图检查某个值是否是其中一个特殊的值。|83nk|例如，gcc+5.2+-O3编译了|1roo8|到(和|6nk4|非常类似的东西)：|a4k5s|errhandler_switch(errtype):++#+gcc+5.2+-O3
++++cmpl++++$32,+%25edi
++++ja++.L5
++++movabsq+$4301325442,+%25rax+++#+highest+set+bit+is+bit+32+(the+33rd+bit)
++++btq+%25rdi,+%25rax
++++jc++.L10
.L5:
++++rep+ret
.L10:
++++jmp+fire_special_event()|code-block|syntax|javascript|fb3a6|请注意，位图是即时数据，因此不会有潜在的数据缓存未命中访问它或跳转表。|e5cpj|gcc+4.9.2+-O3编译了|6k2m0|转换为位图，但|74ech|errhandler_switch(errtype):++#+gcc+4.9.2+-O3
++++leal++++-1(%25rdi),+%25ecx
++++cmpl++++$31,+%25ecx++++#+cmpl+$32,+%25edi++wouldn't+have+to+wait+an+extra+cycle+for+lea's+output.
++++++++++++++#+However,+register+read+ports+are+limited+on+pre-SnB+Intel
++++ja++.L5
++++movl++++$1,+%25eax
++++salq++++%25cl,+%25rax+++#+with+-march=haswell,+it+will+use+BMI's+shlx+to+avoid+moving+the+shift+count+into+ecx
++++testl+++$2150662721,+%25eax
++++jne+.L10
.L5:
++++rep+ret
.L10:
++++jmp+fire_special_event()|8uldb|cmpl++++$32,+%25edi
++++ja++.L5
++++mov+++++$2150662721,+%25eax
++++dec+++++%25edi+++#+movabsq+and+btq+is+fewer+instructions+/+fewer+Intel+uops,+but+this+saves+several+bytes
++++bt+++++%25edi,+%25eax
++++jc++fire_special_event
.L5:
++++ret^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|1A|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|1B|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|1C|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|1D|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|1E|9|@]|A|@]|B|$]]|$2|K|4|F|6|7|8|1F|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|1G|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|1H|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|1I|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|1J|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|1K|9|@]|A|@]|B|$]]|$2|V|4|W|6|X|8|1L|9|@]|A|@]|B|$Y|Z]]|$2|10|4|11|6|7|8|1M|9|@]|A|@]|B|$]]|$2|12|4|13|6|7|8|1N|9|@]|A|@]|B|$]]|$2|14|4|15|6|7|8|1O|9|@]|A|@]|B|$]]|$2|16|4|17|6|X|8|1P|9|@]|A|@]|B|$Y|Z]]|$2|18|4|19|6|X|8|1Q|9|@]|A|@]|B|$Y|Z]]]]

Compilers are really good at optimizing <code>switch</code>. Recent gcc is also good at optimizing a bunch of conditions in an <code>if</code>.

I made some test cases on <a href="https://goo.gl/lYmM1Q" rel="nofollow noreferrer">godbolt</a>.

When the <code>case</code> values are grouped close together, gcc, clang, and icc are all smart enough to use a bitmap to check if a value is one of the special ones.

e.g. gcc 5.2 -O3 compiles the <code>switch</code> to (and the <code>if</code> something very similar):

<pre><code>errhandler_switch(errtype): # gcc 5.2 -O3
 cmpl $32, %edi
 ja .L5
 movabsq $4301325442, %rax # highest set bit is bit 32 (the 33rd bit)
 btq %rdi, %rax
 jc .L10
.L5:
 rep ret
.L10:
 jmp fire_special_event()
</code></pre>

Notice that the bitmap is immediate data, so there's no potential data-cache miss accessing it, or a jump table.

gcc 4.9.2 -O3 compiles the <code>switch</code> to a bitmap, but does the <code>1U&lt;&lt;errNumber</code> with mov/shift. It compiles the <code>if</code> version to series of branches.

<pre><code>errhandler_switch(errtype): # gcc 4.9.2 -O3
 leal -1(%rdi), %ecx
 cmpl $31, %ecx # cmpl $32, %edi wouldn't have to wait an extra cycle for lea's output.
 # However, register read ports are limited on pre-SnB Intel
 ja .L5
 movl $1, %eax
 salq %cl, %rax # with -march=haswell, it will use BMI's shlx to avoid moving the shift count into ecx
 testl $2150662721, %eax
 jne .L10
.L5:
 rep ret
.L10:
 jmp fire_special_event()
</code></pre>

Note how it subtracts 1 from <code>errNumber</code> (with <code>lea</code> to combine that operation with a move). That lets it fit the bitmap into a 32bit immediate, avoiding the 64bit-immediate <code>movabsq</code> which takes more instruction bytes.

A shorter (in machine code) sequence would be:

<pre><code> cmpl $32, %edi
 ja .L5
 mov $2150662721, %eax
 dec %edi # movabsq and btq is fewer instructions / fewer Intel uops, but this saves several bytes
 bt %edi, %eax
 jc fire_special_event
.L5:
 ret
</code></pre>

<hr>

(The failure to use <code>jc fire_special_event</code> is omnipresent, and is <a href="https://gcc.gnu.org/bugzilla/show_bug.cgi?id=42497#c3" rel="nofollow noreferrer">a compiler bug</a>.)

<code>rep ret</code> is used in branch targets, and following conditional branches, for the benefit of old AMD K8 and K10 (pre-Bulldozer): <a href="https://stackoverflow.com/questions/20526361/what-does-rep-ret-mean">What does `rep ret` mean?</a>. Without it, branch prediction doesn't work as well on those obsolete CPUs.

<code>bt</code> (bit test) with a register arg is fast. It combines the work of left-shifting a 1 by <code>errNumber</code> bits and doing a <code>test</code>, but is still 1 cycle latency and only a single Intel uop. It's slow with a memory arg because of its way-too-CISC semantics: with a memory operand for the "bit string", the address of the byte to be tested is computed based on the other arg (divided by 8), and isn't limited to the 1, 2, 4, or 8byte chunk pointed to by the memory operand.

From <a href="http://agner.org/optimize/" rel="nofollow noreferrer">Agner Fog's instruction tables</a>, a variable-count shift instruction is slower than a <code>bt</code> on recent Intel (2 uops instead of 1, and shift doesn't do everything else that's needed).

entityMap|blocks|key|et6a2|text|当涉及到编译程序时，我不知道是否有什么不同。但对于程序本身和尽可能简单的代码，我个人认为这取决于你想要做什么。if+else+if+else语句有其优点，我认为是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4le5|允许您针对特定范围测试变量，您可以将函数(标准库或个人)用作条件。|a7cm6|(示例：|dtkas|`int+a;
+cout<<"enter+value:\n";
+cin>>a;

+if(+a+>+0+&&+a+<+5)
+++{
+++++cout<<"a+is+between+0,+5\n";

+++}else+if(a+>+5+&&+a+<+10)

+++++cout<<"a+is+between+5,10\n";

+++}else{

+++++++"a+is+not+an+integer,+or+is+not+in+range+0,10\n";|code-block|syntax|javascript|43ast|然而，If+else+if+else语句可能会在匆忙中变得复杂和混乱(尽管您尽了最大努力)。Switch语句往往更清晰、更整洁、更易于阅读；但只能用于针对特定值进行测试(例如：|ejdjq|`int+a;
+cout<<"enter+value:\n";
+cin>>a;

+switch(a)
+{
++++case+0:
++++case+1:
++++case+2:+
++++case+3:
++++case+4:
++++case+5:
++++++++cout<<"a+is+between+0,5+and+equals:+"<^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|P|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|Q|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|R|9|@]|A|@]|B|$]]|$2|G|4|H|6|I|8|S|9|@]|A|@]|B|$J|K]]|$2|L|4|M|6|7|8|T|9|@]|A|@]|B|$]]|$2|N|4|O|6|I|8|U|9|@]|A|@]|B|$J|K]]]]

When it comes to compiling the program, I don't know if there is any difference. But as for the program itself and keeping the code as simple as possible, I personally think it depends on what you want to do. if else if else statements have their advantages, which I think are:

allow you to test a variable against specific ranges
you can use functions (Standard Library or Personal) as conditionals.

(example:

<pre><code>`int a;
 cout&lt;&lt;"enter value:\n";
 cin&gt;&gt;a;

 if( a &gt; 0 &amp;&amp; a &lt; 5)
 {
 cout&lt;&lt;"a is between 0, 5\n";

 }else if(a &gt; 5 &amp;&amp; a &lt; 10)

 cout&lt;&lt;"a is between 5,10\n";

 }else{

 "a is not an integer, or is not in range 0,10\n";
</code></pre>

However, If else if else statements can get complicated and messy (despite your best attempts) in a hurry. Switch statements tend to be clearer, cleaner, and easier to read; but can only be used to test against specific values (example:

<pre><code>`int a;
 cout&lt;&lt;"enter value:\n";
 cin&gt;&gt;a;

 switch(a)
 {
 case 0:
 case 1:
 case 2: 
 case 3:
 case 4:
 case 5:
 cout&lt;&lt;"a is between 0,5 and equals: "&lt;&lt;a&lt;&lt;"\n";
 break;
 //other case statements
 default:
 cout&lt;&lt;"a is not between the range or is not a good value\n"
 break;
</code></pre>

I prefer if - else if - else statements, but it really is up to you. If you want to use functions as the conditions, or you want to test something against a range, array, or vector and/or you don't mind dealing with the complicated nesting, I would recommend using If else if else blocks. If you want to test against single values or you want a clean and easy to read block, I would recommend you use switch() case blocks.

entityMap|blocks|key|4g081|text|很抱歉不同意当前接受的答案。这是2021年。现代编译器和它们的优化器不应该区分|type|unstyled|depth|inlineStyleRanges|entityRanges|data|50l3t|和等效的|70m9k|不再是-chain了。如果他们仍然这样做，并且为任何一种变体创建了不佳的优化代码，那么请写信给编译器供应商(或者在这里公开它，它具有更高的被尊重的变化)，但不要让微优化影响你的编码风格。|a425s|因此，如果您使用：|fe4oc|switch+(numError)+{+case+ERROR_A:+case+ERROR_B:+...+}|code-block|syntax|javascript|8u7oh|或者：|9sg4r|if(numError+==+ERROR_A+%7C%7C+numError+==+ERROR_B+%7C%7C+...)+{+...+}|1el1r|5n1pq|template
bool+has(const+C&+cont,+const+EL&+el)+{
++++return+std::find(cont.begin(),+cont.end(),+el)+!=+cont.end();
}

constexpr+std::array+errList+=+{+ERROR_A,+ERROR_B,+...+};
if(has(errList,+rnd))+{+...+}|fs0mf|在执行速度方面不应该有什么不同。但是，根据您正在处理的项目，它们在代码清晰度和代码可维护性方面可能会有很大的不同。例如，如果您必须在代码的许多位置检查某个错误列表，则模板|8fa1s|可能更容易维护，因为errList只需要在一个地方更新。|9k7cb|谈到当前的编译器，我已经用这两个编译器编译了下面引用的测试代码|1vmrc|(版本10和11)和|jqou|..。两个clang版本都提供了相似的编译代码和执行时间。因此，从现在开始，我只讨论版本11。最值得注意的是，|f73bu|(它使用|bv6no|)和|5r3hr|700ce|)生成完全相同的汇编程序输出|1hnoq|啊！和|fkgmc|使用跳转表，尽管许多其他发帖者认为跳转表是|8mfq0|..。然而，尽管许多人认为跳转表是最优的，但这实际上是|a6hg|：|12uen|需要大约20%25的执行时间|a4igl|或者|7ljt6|..。|45pdh|手工优化的版本|1924k|是到目前为止最快的|82jsa|..。它甚至部分地展开了循环，对每个循环进行了两次迭代。|3u5i6|实际上，|9kue5|计算位域，它显式地提供在|as5s|，也在|3e9c8|和|7rdn0|..。但是，它在|ab4jf|f6gpu|，这使得它们变得很慢，因为分支预测经常失败，而它使用的效率要高得多。|ae4ki|("add+with+carry")中|2q0hb|..。虽然它未能在其他变体中应用这种明显的优化，但我不知道。|e21n5|生成的代码|21ua8|看起来比|836l5|-但实际上运行的速度要快一些|4ab2s|而且速度要快得多|5mnd0|..。在非手动优化的函数中，|db6o1|是最快的|7fhth|，并且比上的任何函数都要快。|3pv61|..。恰恰相反，|554v9|编译时需要两倍的执行时间。|5n0sc|而不是with|b6sjt|，主要是因为|ab752|不会展开循环。|8og1e|具体结果如下：|b40gg|clang:
functionA:+109877+3627
functionB:+109877+3626
functionC:+109877+4192
functionH:+109877+524

g%2B%2B:
functionA:+109877+3337
functionB:+109877+4668
functionC:+109877+2890
functionH:+109877+982|fmaof|性能会有很大的变化，如果常量|46bfv|被更改为|8g3qk|在整个代码中：|856up|clang:
functionA:+106943+1435
functionB:+106943+1436
functionC:+106943+4191
functionH:+106943+524

g%2B%2B:
functionA:+106943+1265
functionB:+106943+4481
functionC:+106943+2804
functionH:+106943+1038|i0qo|加速的原因是，在最高测试值为63的情况下，编译器删除了一些不必要的界限检查，因为|6gf8e|不管怎么说，都是63。请注意，删除该绑定检查后，未优化的|qpn7|使用简单|979gl|打开|2cmhi|执行速度几乎与手动优化的|5kp2r|，它也产生了非常相似的汇编输出。|3etnt|结论是什么？如果你经常手工优化和测试编译器，你会得到最快的解决方案。任何假设|81gm5|419pc|是更好的，是无效的-它们是相同的|3qu0l|..。和一个易于编写代码的解决方案来检查|c3hv9|实际上是最快的情况|7fu0q|(如果省略了手动优化和按事件匹配列表的最后一个值)。|dmp1h|未来的编译器版本将会越来越好地优化你的代码，并且离你的手工优化更近了一步。所以不要浪费你的时间，除非周期对你来说真的很重要。|cbh67|下面是测试代码：|7q51t|#include+
#include+
#include+
#include+
#include+

unsigned+long+long+functionA()+{
++++unsigned+long+long+cnt+=+0;

++++for(unsigned+long+long+i+=+0;+i+<+1000000;+i%2B%2B)+{
++++++++unsigned+char+rnd+=+(((i+*+(i+>>+3))+>>+8)+%5E+i)+&+63;
++++++++if(rnd+==+1+%7C%7C+rnd+==+7+%7C%7C+rnd+==+10+%7C%7C+rnd+==+16+%7C%7C
+++++++++++rnd+==+21+%7C%7C+rnd+==+22+%7C%7C+rnd+==+63)
++++++++{
++++++++++++cnt+%2B=+1;
++++++++}
++++}

++++return+cnt;
}

unsigned+long+long+functionB()+{
++++unsigned+long+long+cnt+=+0;

++++for(unsigned+long+long+i+=+0;+i+<+1000000;+i%2B%2B)+{
++++++++unsigned+char+rnd+=+(((i+*+(i+>>+3))+>>+8)+%5E+i)+&+63;
++++++++switch(rnd)+{
++++++++case+1:
++++++++case+7:
++++++++case+10:
++++++++case+16:
++++++++case+21:
++++++++case+22:
++++++++case+63:
++++++++++++cnt%2B%2B;
++++++++++++break;
++++++++}
++++}

++++return+cnt;
}

template
bool+has(const+C&+cont,+const+EL&+el)+{
++++return+std::find(cont.begin(),+cont.end(),+el)+!=+cont.end();
}

unsigned+long+long+functionC()+{
++++unsigned+long+long+cnt+=+0;
++++constexpr+std::array+errList+{+1,+7,+10,+16,+21,+22,+63+};

++++for(unsigned+long+long+i+=+0;+i+<+1000000;+i%2B%2B)+{
++++++++unsigned+char+rnd+=+(((i+*+(i+>>+3))+>>+8)+%5E+i)+&+63;
++++++++cnt+%2B=+has(errList,+rnd);
++++}

++++return+cnt;
}

//+Hand+optimized+version+(manually+created+bitfield):
unsigned+long+long+functionH()+{
++++unsigned+long+long+cnt+=+0;

++++const+unsigned+long+long+bitfield+=
++++++++(1ULL+<<+1)+%2B
++++++++(1ULL+<<+7)+%2B
++++++++(1ULL+<<+10)+%2B
++++++++(1ULL+<<+16)+%2B
++++++++(1ULL+<<+21)+%2B
++++++++(1ULL+<<+22)+%2B
++++++++(1ULL+<<+63);

++++for(unsigned+long+long+i+=+0;+i+<+1000000;+i%2B%2B)+{
++++++++unsigned+char+rnd+=+(((i+*+(i+>>+3))+>>+8)+%5E+i)+&+63;
++++++++if(bitfield+&+(1ULL+<<+rnd))+{
++++++++++++cnt+%2B=+1;
++++++++}
++++}

++++return+cnt;
}

void+timeit(unsigned+long+long+(*function)(),+const+char*+message)
{
++++unsigned+long+long+mintime+=+std::numeric_limits::max();
++++unsigned+long+long+fres+=+0;

++++for(int+i+=+0;+i+<+100;+i%2B%2B)+{
++++++++auto+t1+=+std::chrono::high_resolution_clock::now();
++++++++fres+=+function();
++++++++auto+t2+=+std::chrono::high_resolution_clock::now();

++++++++auto+duration+=+std::chrono::duration_cast(t2+-+t1).count();
++++++++if(duration+<+mintime)+{
++++++++++++mintime+=+duration;
++++++++}
++++}

++++std::cout+<<+message+<<+fres+<<+"+"+<<+mintime+<<+std::endl;
}


int+main(int+argc,+char*+argv[])+{
++++timeit(functionA,+"functionA:+");
++++timeit(functionB,+"functionB:+");
++++timeit(functionC,+"functionC:+");
++++timeit(functionH,+"functionH:+");
++++timeit(functionA,+"functionA:+");
++++timeit(functionB,+"functionB:+");
++++timeit(functionC,+"functionC:+");
++++timeit(functionH,+"functionH:+");
++++timeit(functionA,+"functionA:+");
++++timeit(functionB,+"functionB:+");
++++timeit(functionC,+"functionC:+");
++++timeit(functionH,+"functionH:+");

++++return+0;
}^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|45|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|46|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|47|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|48|9|@]|A|@]|B|$]]|$2|I|4|J|6|K|8|49|9|@]|A|@]|B|$L|M]]|$2|N|4|O|6|7|8|4A|9|@]|A|@]|B|$]]|$2|P|4|Q|6|K|8|4B|9|@]|A|@]|B|$L|M]]|$2|R|4|O|6|7|8|4C|9|@]|A|@]|B|$]]|$2|S|4|T|6|K|8|4D|9|@]|A|@]|B|$L|M]]|$2|U|4|V|6|7|8|4E|9|@]|A|@]|B|$]]|$2|W|4|X|6|7|8|4F|9|@]|A|@]|B|$]]|$2|Y|4|Z|6|7|8|4G|9|@]|A|@]|B|$]]|$2|10|4|11|6|7|8|4H|9|@]|A|@]|B|$]]|$2|12|4|13|6|7|8|4I|9|@]|A|@]|B|$]]|$2|14|4|15|6|7|8|4J|9|@]|A|@]|B|$]]|$2|16|4|17|6|7|8|4K|9|@]|A|@]|B|$]]|$2|18|4|15|6|7|8|4L|9|@]|A|@]|B|$]]|$2|19|4|1A|6|7|8|4M|9|@]|A|@]|B|$]]|$2|1B|4|1C|6|7|8|4N|9|@]|A|@]|B|$]]|$2|1D|4|1E|6|7|8|4O|9|@]|A|@]|B|$]]|$2|1F|4|1G|6|7|8|4P|9|@]|A|@]|B|$]]|$2|1H|4|1I|6|7|8|4Q|9|@]|A|@]|B|$]]|$2|1J|4|1K|6|7|8|4R|9|@]|A|@]|B|$]]|$2|1L|4|1M|6|7|8|4S|9|@]|A|@]|B|$]]|$2|1N|4|1O|6|7|8|4T|9|@]|A|@]|B|$]]|$2|1P|4|1Q|6|7|8|4U|9|@]|A|@]|B|$]]|$2|1R|4|1S|6|7|8|4V|9|@]|A|@]|B|$]]|$2|1T|4|1U|6|7|8|4W|9|@]|A|@]|B|$]]|$2|1V|4|1W|6|7|8|4X|9|@]|A|@]|B|$]]|$2|1X|4|1Y|6|7|8|4Y|9|@]|A|@]|B|$]]|$2|1Z|4|20|6|7|8|4Z|9|@]|A|@]|B|$]]|$2|21|4|22|6|7|8|50|9|@]|A|@]|B|$]]|$2|23|4|24|6|7|8|51|9|@]|A|@]|B|$]]|$2|25|4|22|6|7|8|52|9|@]|A|@]|B|$]]|$2|26|4|27|6|7|8|53|9|@]|A|@]|B|$]]|$2|28|4|29|6|7|8|54|9|@]|A|@]|B|$]]|$2|2A|4|2B|6|7|8|55|9|@]|A|@]|B|$]]|$2|2C|4|2D|6|7|8|56|9|@]|A|@]|B|$]]|$2|2E|4|2F|6|7|8|57|9|@]|A|@]|B|$]]|$2|2G|4|2H|6|7|8|58|9|@]|A|@]|B|$]]|$2|2I|4|2J|6|7|8|59|9|@]|A|@]|B|$]]|$2|2K|4|2L|6|7|8|5A|9|@]|A|@]|B|$]]|$2|2M|4|2N|6|7|8|5B|9|@]|A|@]|B|$]]|$2|2O|4|2P|6|7|8|5C|9|@]|A|@]|B|$]]|$2|2Q|4|2R|6|7|8|5D|9|@]|A|@]|B|$]]|$2|2S|4|2T|6|7|8|5E|9|@]|A|@]|B|$]]|$2|2U|4|2V|6|7|8|5F|9|@]|A|@]|B|$]]|$2|2W|4|2X|6|7|8|5G|9|@]|A|@]|B|$]]|$2|2Y|4|2Z|6|7|8|5H|9|@]|A|@]|B|$]]|$2|30|4|31|6|7|8|5I|9|@]|A|@]|B|$]]|$2|32|4|33|6|K|8|5J|9|@]|A|@]|B|$L|M]]|$2|34|4|35|6|7|8|5K|9|@]|A|@]|B|$]]|$2|36|4|37|6|7|8|5L|9|@]|A|@]|B|$]]|$2|38|4|39|6|7|8|5M|9|@]|A|@]|B|$]]|$2|3A|4|3B|6|K|8|5N|9|@]|A|@]|B|$L|M]]|$2|3C|4|3D|6|7|8|5O|9|@]|A|@]|B|$]]|$2|3E|4|3F|6|7|8|5P|9|@]|A|@]|B|$]]|$2|3G|4|3H|6|7|8|5Q|9|@]|A|@]|B|$]]|$2|3I|4|3J|6|7|8|5R|9|@]|A|@]|B|$]]|$2|3K|4|3L|6|7|8|5S|9|@]|A|@]|B|$]]|$2|3M|4|3N|6|7|8|5T|9|@]|A|@]|B|$]]|$2|3O|4|3P|6|7|8|5U|9|@]|A|@]|B|$]]|$2|3Q|4|1M|6|7|8|5V|9|@]|A|@]|B|$]]|$2|3R|4|3S|6|7|8|5W|9|@]|A|@]|B|$]]|$2|3T|4|3U|6|7|8|5X|9|@]|A|@]|B|$]]|$2|3V|4|3W|6|7|8|5Y|9|@]|A|@]|B|$]]|$2|3X|4|3Y|6|7|8|5Z|9|@]|A|@]|B|$]]|$2|3Z|4|40|6|7|8|60|9|@]|A|@]|B|$]]|$2|41|4|42|6|7|8|61|9|@]|A|@]|B|$]]|$2|43|4|44|6|K|8|62|9|@]|A|@]|B|$L|M]]]]

Sorry to disagree with the current accepted answer. This is the year 2021. Modern compilers and their optimizers shouldn't differentiate between <code>switch</code> and an equivalent <code>if</code>-chain anymore. If they still do, and create poorly optimized code for either variant, then write to the compiler vendor (or make it public here, which has a higher change of being respected), but don't let micro-optimizations influence your coding style.
So, if you use:
<pre><code>switch (numError) { case ERROR_A: case ERROR_B: ... }
</code></pre>
or:
<pre><code>if(numError == ERROR_A || numError == ERROR_B || ...) { ... }
</code></pre>
or:
<pre><code>template&lt;typename C, typename EL&gt;
bool has(const C&amp; cont, const EL&amp; el) {
 return std::find(cont.begin(), cont.end(), el) != cont.end();
}

constexpr std::array errList = { ERROR_A, ERROR_B, ... };
if(has(errList, rnd)) { ... }
</code></pre>
shouldn't make a difference with respect to execution speed. But depending on what project you are working on, they might make a big difference in coding clarity and code maintainability. For example, if you have to check for a certain error list in many places of the code, the templated <code>has()</code> might be much easier to maintain, as the errList needs to be updated only in one place.
Talking about current compilers, I have compiled the test code quoted below with both <code>clang++ -O3 -std=c++1z</code> (version 10 and 11) and <code>g++ -O3 -std=c++1z</code>. Both clang versions gave similiar compiled code and execution times. So I am talking only about version 11 from now on. Most notably, <code>functionA()</code> (which uses <code>if</code>) and <code>functionB()</code> (which uses <code>switch</code>) produce exactly the same assembler output with <code>clang</code>! And <code>functionC()</code> uses a jump table, even though many other posters deemed jump tables to be an exclusive feature of <code>switch</code>. However, despite many people considering jump tables to be optimal, that was actually the slowest solution on <code>clang</code>: <code>functionC()</code> needs around 20 percent more execution time than <code>functionA()</code> or <code>functionB()</code>.
The hand-optimized version <code>functionH()</code> was by far the fastest on <code>clang</code>. It even unrolled the loop partially, doing two iterations on each loop.
Actually, <code>clang</code> calculated the bitfield, which is explicitely supplied in <code>functionH()</code>, also in <code>functionA()</code> and <code>functionB()</code>. However, it used conditional branches in <code>functionA()</code> and <code>functionB()</code>, which made these slow, because branch prediction fails regularly, while it used the much more efficient <code>adc</code> (&quot;add with carry&quot;) in <code>functionH()</code>. While it failed to apply this obvious optimization also in the other variants, is unknown to me.
The code produced by <code>g++</code> looks much more complicated than that of <code>clang</code> - but actually runs a bit faster for <code>functionA()</code> and quite a lot faster for <code>functionC()</code>. Of the non-hand-optimized functions, <code>functionC()</code> is the fastest on <code>g++</code> and faster than any of the functions on <code>clang</code>. On the contrary, <code>functionH()</code> requires twice the execution time when compiled with <code>g++</code> instead of with <code>clang</code>, mostly because <code>g++</code> doesn't do the loop unrolling.
Here are the detailed results:
<pre><code>clang:
functionA: 109877 3627
functionB: 109877 3626
functionC: 109877 4192
functionH: 109877 524

g++:
functionA: 109877 3337
functionB: 109877 4668
functionC: 109877 2890
functionH: 109877 982
</code></pre>
The Performance changes drastically, if the constant <code>32</code> is changed to <code>63</code> in the whole code:
<pre><code>clang:
functionA: 106943 1435
functionB: 106943 1436
functionC: 106943 4191
functionH: 106943 524

g++:
functionA: 106943 1265
functionB: 106943 4481
functionC: 106943 2804
functionH: 106943 1038
</code></pre>
The reason for the speedup is, that in case, that the highest tested value is 63, the compilers remove some unnecessary bound checks, because the value of <code>rnd</code> is bound to 63, anyways. Note that with that bound check removed, the non-optimized <code>functionA()</code> using simple <code>if()</code> on <code>g++</code> performs almost as fast as the hand-optimized <code>functionH()</code>, and it also produces rather similiar assembler output.
What is the conclusion? If you hand-optimize and test compilers a lot, you will get the fastest solution. Any assumption whether <code>switch</code> or <code>if</code> is better, is void - they are the same on <code>clang</code>. And the easy to code solution to check against an <code>array</code> of values is actually the fastest case on <code>g++</code> (if leaving out hand-optimization and by-incident matching last values of the list).
Future compiler versions will optimize your code better and better and get closer to your hand optimization. So don't waste your time on it, unless cycles are REALLY crucial in your case.
Here the test code:
<pre><code>#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;limits&gt;
#include &lt;array&gt;
#include &lt;algorithm&gt;

unsigned long long functionA() {
 unsigned long long cnt = 0;

 for(unsigned long long i = 0; i &lt; 1000000; i++) {
 unsigned char rnd = (((i * (i &gt;&gt; 3)) &gt;&gt; 8) ^ i) &amp; 63;
 if(rnd == 1 || rnd == 7 || rnd == 10 || rnd == 16 ||
 rnd == 21 || rnd == 22 || rnd == 63)
 {
 cnt += 1;
 }
 }

 return cnt;
}

unsigned long long functionB() {
 unsigned long long cnt = 0;

 for(unsigned long long i = 0; i &lt; 1000000; i++) {
 unsigned char rnd = (((i * (i &gt;&gt; 3)) &gt;&gt; 8) ^ i) &amp; 63;
 switch(rnd) {
 case 1:
 case 7:
 case 10:
 case 16:
 case 21:
 case 22:
 case 63:
 cnt++;
 break;
 }
 }

 return cnt;
}

template&lt;typename C, typename EL&gt;
bool has(const C&amp; cont, const EL&amp; el) {
 return std::find(cont.begin(), cont.end(), el) != cont.end();
}

unsigned long long functionC() {
 unsigned long long cnt = 0;
 constexpr std::array errList { 1, 7, 10, 16, 21, 22, 63 };

 for(unsigned long long i = 0; i &lt; 1000000; i++) {
 unsigned char rnd = (((i * (i &gt;&gt; 3)) &gt;&gt; 8) ^ i) &amp; 63;
 cnt += has(errList, rnd);
 }

 return cnt;
}

// Hand optimized version (manually created bitfield):
unsigned long long functionH() {
 unsigned long long cnt = 0;

 const unsigned long long bitfield =
 (1ULL &lt;&lt; 1) +
 (1ULL &lt;&lt; 7) +
 (1ULL &lt;&lt; 10) +
 (1ULL &lt;&lt; 16) +
 (1ULL &lt;&lt; 21) +
 (1ULL &lt;&lt; 22) +
 (1ULL &lt;&lt; 63);

 for(unsigned long long i = 0; i &lt; 1000000; i++) {
 unsigned char rnd = (((i * (i &gt;&gt; 3)) &gt;&gt; 8) ^ i) &amp; 63;
 if(bitfield &amp; (1ULL &lt;&lt; rnd)) {
 cnt += 1;
 }
 }

 return cnt;
}

void timeit(unsigned long long (*function)(), const char* message)
{
 unsigned long long mintime = std::numeric_limits&lt;unsigned long long&gt;::max();
 unsigned long long fres = 0;

 for(int i = 0; i &lt; 100; i++) {
 auto t1 = std::chrono::high_resolution_clock::now();
 fres = function();
 auto t2 = std::chrono::high_resolution_clock::now();

 auto duration = std::chrono::duration_cast&lt;std::chrono::microseconds&gt;(t2 - t1).count();
 if(duration &lt; mintime) {
 mintime = duration;
 }
 }

 std::cout &lt;&lt; message &lt;&lt; fres &lt;&lt; &quot; &quot; &lt;&lt; mintime &lt;&lt; std::endl;
}


int main(int argc, char* argv[]) {
 timeit(functionA, &quot;functionA: &quot;);
 timeit(functionB, &quot;functionB: &quot;);
 timeit(functionC, &quot;functionC: &quot;);
 timeit(functionH, &quot;functionH: &quot;);
 timeit(functionA, &quot;functionA: &quot;);
 timeit(functionB, &quot;functionB: &quot;);
 timeit(functionC, &quot;functionC: &quot;);
 timeit(functionH, &quot;functionH: &quot;);
 timeit(functionA, &quot;functionA: &quot;);
 timeit(functionB, &quot;functionB: &quot;);
 timeit(functionC, &quot;functionC: &quot;);
 timeit(functionH, &quot;functionH: &quot;);

 return 0;
}
</code></pre>

What's the best practice for using a <code>switch</code> statement vs using an <code>if</code> statement for 30 <code>unsigned</code> enumerations where about 10 have an expected action (that presently is the same action). Performance and space need to be considered but are not critical. I've abstracted the snippet so don't hate me for the naming conventions.

<code>switch</code> statement:

<pre><code>// numError is an error enumeration type, with 0 being the non-error case
// fire_special_event() is a stub method for the shared processing

switch (numError)
{ 
 case ERROR_01 : // intentional fall-through
 case ERROR_07 : // intentional fall-through
 case ERROR_0A : // intentional fall-through
 case ERROR_10 : // intentional fall-through
 case ERROR_15 : // intentional fall-through
 case ERROR_16 : // intentional fall-through
 case ERROR_20 :
 {
 fire_special_event();
 }
 break;

 default:
 {
 // error codes that require no additional action
 }
 break; 
}
</code></pre>

<code>if</code> statement:

<pre><code>if ((ERROR_01 == numError) ||
 (ERROR_07 == numError) ||
 (ERROR_0A == numError) || 
 (ERROR_10 == numError) ||
 (ERROR_15 == numError) ||
 (ERROR_16 == numError) ||
 (ERROR_20 == numError))
{
 fire_special_event();
}
</code></pre>

Advantage of switch over if-else statement

数据缓存

编译器

调试器

Python

 使用 语句与使用 30的语句 枚举，其中大约10个具有预期的操作(目前是相同的操作)。性能和空间需要考虑，但不是关键因素。我已经对代码片段进行了抽象，所以请不要因为命名约定而讨厌我。 声明： // numError is an error enumeration type, with 0 being the non-...

问switch优于if-else语句的优点
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问switch优于if-else语句的优点EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问switch优于if-else语句的优点
EN