switch和if-else相比

最新推荐文章于 2024-09-14 12:00:48 发布
最新推荐文章于 2024-09-14 12:00:48 发布
阅读量332 收藏
点赞数
分类专栏： java 文章标签： 汇编 string class gcc 编译器 tree

switch和if-else相比，由于使用了Binary Tree算法，绝大部分情况下switch会快一点，除非是if-else的第一个条件就为true.说实话  我也没有深入研究过这个问题的根源只是在实际开发中  没有人会去用很多很多else if的都是用 switch case 的  后者比较清晰  给人感觉就是一个脑子很清楚的人写出来的东西至于效率的本质  就让大企鹅去操心吧
编译器编译switch与编译if...else...不同。不管有多少case，都直接跳转，不需逐个比较查询。
昨天发现了一本叫做CSAPP的书，终于找到了关于switch问题的解答。

这是一段C代码： 

view plain
  1. /* $begin switch-c */  
  2. int switch_eg(int x)  
  3. {  
  4.     int result = x;  
  5.   
  6.     switch (x) {  
  7.   
  8.     case 100:  
  9.     result *= 13;  
  10.     break;  
  11.   
  12.     case 102:  
  13.     result += 10;  
  14.     /* Fall through */  
  15.   
  16.     case 103:  
  17.     result += 11;  
  18.     break;  
  19.   
  20.     case 104:  
  21.     case 106:  
  22.     result *= result;  
  23.     break;  
  24.   
  25.     default:  
  26.     result = 0;        
  27.     }  
  28.   
  29.     return result;  
  30. }  
  31. /* $end switch-c */   

用GCC汇编出来的代码如下： 

view plain
  1. .file    "switch.c"  
  2.     .version    "01.01"  
  3. gcc2_compiled.:  
  4. .text  
  5.     .align 4  
  6. .globl switch_eg  
  7.     .type     switch_eg,@function  
  8. switch_eg:  
  9.     pushl %ebp  
  10.     movl %esp,%ebp  
  11.     movl 8(%ebp),%edx  
  12.     leal -100(%edx),%eax  
  13.     cmpl ,%eax  
  14.     ja .L9  
  15.     jmp *.L10(,%eax,4)  
  16.     .p2align 4,,7  
  17. .section    .rodata  
  18.     .align 4  
  19.     .align 4  
  20. .L10:  
  21.     .long .L4  
  22.     .long .L9  
  23.     .long .L5  
  24.     .long .L6  
  25.     .long .L8  
  26.     .long .L9  
  27.     .long .L8  
  28. .text  
  29.     .p2align 4,,7  
  30. .L4:  
  31.     leal (%edx,%edx,2),%eax  
  32.     leal (%edx,%eax,4),%edx  
  33.     jmp .L3  
  34.     .p2align 4,,7  
  35. .L5:  
  36.     addl ,%edx  
  37. .L6:  
  38.     addl ,%edx  
  39.     jmp .L3  
  40.     .p2align 4,,7  
  41. .L8:  
  42.     imull %edx,%edx  
  43.     jmp .L3  
  44.     .p2align 4,,7  
  45. .L9:  
  46.     xorl %edx,%edx  
  47. .L3:  
  48.     movl %edx,%eax  
  49.     movl %ebp,%esp  
  50.     popl %ebp  
  51.     ret  
  52. .Lfe1:  
  53.     .size     switch_eg,.Lfe1-switch_eg  
  54.     .ident    "GCC: (GNU) 2.95.3 20010315 (release)"   

在上面的汇编代码中我们可以很清楚的看到switch部分被分配了一个连续的查找表，switch case中不连续的部分也被添加上了相应的条目，switch表的大小不是根据case语句的多少，而是case的最大值的最小值之间的间距。在选择相应 的分支时，会先有一个cmp子句，如果大于查找表的最大值，则跳转到default子句。而其他所有的case语句的耗时都回事O(1)。
相比于if-else结构，switch的效率绝对是要高很多的，但是switch使用查找表的方式决定了case的条件必须是一个连续的常量。而if-else则可以灵活的多。

可以看到if-else只是单纯地一个接一个比较，效率比较低 
可以看出，switch的效率一般比if-else高 
switch   效率高,     从汇编代码可以看出来   
switch   只计算一次值   然后都是test   ,   jmp,     
if...else   是每个条件都要计算一遍的.  
switch的效率与分支数无关   
当只有分支比较少的时候，if效率比switch高（因为switch有跳转表）   

分支比较多，那当然是switch

---------------------------------------------------------------------------------------------------------------------------------

switch可以进行跳转优化，java中对switch有两种处理方式，生成不同的jvm指令，一是tableswitch，一个是lookupswitch.
对于case的分支比较密集的情况，如

public class Test {

    public static void main(String[] args) {
        int i = 3;
        switch (i) {
            case 0:
                System.out.println("0");
                break;
            case 1:
                System.out.println("1");
                break;
            case 3:
                System.out.println("3");
                break;
            case 5:
                System.out.println("5");
                break;
            case 10:
                System.out.println("10");
                break;
            case 13:
                System.out.println("13");
                break;
            case 14:
                System.out.println("14");
                break;
        default:
        System.out.println("default");
                break;
        }


    }
}

使用tableswitch,得到 

public static void main(java.lang.String[]);
  Code:
   0:    iconst_3
   1:    istore_1
   2:    iload_1
   3:    tableswitch{ //0 to 14
        0: 76;
        1: 87;
        2: 153;
        3: 98;
        4: 153;
        5: 109;
        6: 153;
        7: 153;
        8: 153;
        9: 153;
        10: 120;
        11: 153;
        12: 153;
        13: 131;
        14: 142;
        default: 153 }
   76:    getstatic    #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   79:    ldc    #3; //String 0
   81:    invokevirtual    #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   84:    goto    161
   87:    getstatic    #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   90:    ldc    #5; //String 1
   92:    invokevirtual    #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   95:    goto    161
   98:    getstatic    #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   101:    ldc    #6; //String 3
   103:    invokevirtual    #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   106:    goto    161
   109:    getstatic    #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   112:    ldc    #7; //String 5
   114:    invokevirtual    #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   117:    goto    161
   120:    getstatic    #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   123:    ldc    #8; //String 10
   125:    invokevirtual    #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   128:    goto    161
   131:    getstatic    #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   134:    ldc    #9; //String 13
   136:    invokevirtual    #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   139:    goto    161
   142:    getstatic    #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   145:    ldc    #10; //String 14
   147:    invokevirtual    #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   150:    goto    161
   153:    getstatic    #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   156:    ldc    #11; //String default
   158:    invokevirtual    #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   161:    return

}

从中可以看到tableswitch使用的跳转表。它这样查找，如果case值不在//0 to 14之间，直接执行default,如果在此范围之内，则取目标值-0这一项作为目标，比如switch(i),i为３，则跳转到3-0=3,使用数组中的第三项作为目标，也就是3: 98;直接去执行９８行。

如果case中的值比较稀疏，则使用lookupswitch: 

public class Test2 {

    public static void main(String[] args) {
        int i = 3;
        switch (i) {
            case 3:
                System.out.println("3");
                break;
            case 20:
                System.out.println("20");
                break;
            case 50:
                System.out.println("50");
                break;
            case 100:
                System.out.println("100");
                break;
        }


    }
}

编译为 

public static void main(java.lang.String[]); 
   Code: 
    0:	iconst_3 
    1:	istore_1 
    2:	iload_1 
    3:	lookupswitch{ //4 
 		3: 44; 
 		20: 55; 
 		50: 66; 
 		100: 77; 
 		default: 85 } 
    44:	getstatic	#2; //Field java/lang/System.out:Ljava/io/PrintStream; 
    47:	ldc	#3; //String 3 
    49:	invokevirtual	#4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 
    52:	goto	85 
    55:	getstatic	#2; //Field java/lang/System.out:Ljava/io/PrintStream; 
    58:	ldc	#5; //String 20 
    60:	invokevirtual	#4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 
    63:	goto	85 
    66:	getstatic	#2; //Field java/lang/System.out:Ljava/io/PrintStream; 
    69:	ldc	#6; //String 50 
    71:	invokevirtual	#4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 
    74:	goto	85 
    77:	getstatic	#2; //Field java/lang/System.out:Ljava/io/PrintStream; 
    80:	ldc	#7; //String 100 
    82:	invokevirtual	#4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 
    85:	return

可以看到其中的
 3: lookupswitch{ //4
3: 44;
20: 55;
50: 66;
100: 77;
default: 85 }
这个就要挨着查表确定跳转位置了

liuhl_h
关注
专栏目录
语句效率问题_switch和if-else相比
coder
07-13 1942
switch和if-else相比 switch和if-else相比，由于使用了Binary Tree算法，绝大部分情况下switch会快一点，除非是if-else的第一个条件就为true. 原理：switch...case会生成一个跳转表来指示实际的case分支的地址，而这个跳转表的索引号与switch变量的值是相等的。从而，switch...case不用像if...else那样遍历条件分支直
switch语句和if-else语句
weixin_37856170的博客
08-07 182
缺点：switch的参数只能是整型或字符型，不能是一个区间，不如if-else灵活。switch语句相比if-else语句，
C语言——if-else和switch-case
2301_79243247的博客
02-19 934
switch case 语句在处理多分支情况时可以提供一种结构清晰、易于维护的方式，但在某些复杂的逻辑或需要更灵活的条件判断时，可能仍然需要使用 if-else 语句。1. 多分支选择：当需要根据一个变量或表达式的值来执行多个不同的分支操作时， switch case 比使用多个 if-else 语句更加清晰和简洁。5. 代码效率：在某些情况下， switch case 的执行效率可能比多个连续的 if-else 语句更高，因为它可以通过跳转表实现快速的分支跳转。
if-else 和 switch-case的区别
luckycoming的博客
08-18 699
if-else 和 switch-case 都是 JavaScript 中常用的条件语句，用于根据条件执行不同的代码块。本文介绍了它们之间的区别和各自的优缺点：
switch-case和if-else的效率比较·必看
红目香薰
03-20 1315
绝大多数的程序员喜欢使用if判断，但是真的效率高吗？还是其它的，可能只会用if呢！我们今天就具体测一测，用事实说话，测试量100W： 理论上，switch是利用空间换时间。为了避免实验干扰，先行执行了gc()操作，后面提示了对应的内存消耗。 本文采用的是【Java】语言进行测试，后续会有【Python】【C#】 switch效率测试代码： public static void main(String[] args) { /** * switch与if效率测试·测试
switch跟if-else性能比较
xiaohubeiplus的博客
05-19 2288
switch和if-else性能比较 switch和if-else相比，由于使用了Binary Tree算法，绝大部分情况下switch会快一点，除非是if-else的第一个条件就为true.说实话  我也没有深入研究过这个问题的根源只是在实际开发中  没有人会去用很多很多else if的都是用 switch case 的  后者比较清晰  给人感觉就是一个脑子很清楚的人写出来的东西至于效率的本
if-else和switch的练习及区别比较
well_KD的博客
07-29 369
if-else和switch二者的区别，以及他们在不同的实际场景中的选择应用
switch和if-else性能比较
dawning126的专栏
10-19 243
switch和if-else相比，由于使用了Binary Tree算法，绝大部分情况下switch会快一点，除非是if-else的第一个条件就为true.说实话 我也没有深入研究过这个问题的根源只是在实际开发中 没有人会去用很多很多else if的都是用 switch case 的 后者比较清晰 给人感觉就是一个脑子很清楚的人写出来的东西至于效率的本质 就让大企鹅去操心吧 编译器编译s...
c语言中switch中else,C语言中if-else与switch
weixin_29879697的博客
05-23 1686
if-else vs switch什么是if-else语句？C编程中的if-else语句是一个条件语句，该条件语句基于true或false条件执行一组不同的语句。仅当指定条件为真时才执行“ if”块，如果指定条件为假，则将执行else块。if-else语句的语法如下：什么是switch语句？switch语句是C编程中使用的条件语句，用于检查变量的值并将其与所有情况进行比较。如果该值与任何情况都匹配...
switch函数与if-else语句的比较
在本章节中，将介绍文章的主题，简要概述switch函数和if-else语句的作用。 # 2. **if-else语句的原理和用法** if-else语句是编程中常用的控制流语句，用于根据条件的真假执行不同的代码块。下面将详细介绍if-else...
掌握C语言条件语句：if-else和switch-case语句的使用
本文将详细介绍C语言中的条件语句，包括if-else语句和switch-case语句的基本语法、用法和技巧，以及在实际编程中的应用和错误处理。通过学习本文，读者将能够全面掌握C语言条件语句的核心知识和实际运用技巧。 ## ...
If-else 和 Switch 之间的区别
新华编程特战队
12-08 49
在我们的日常生活中，我们会做出几个决定，从决定穿什么到决定吃什么。有时你的行动取决于你的决定。例如，如果你已经刷过牙，你可以吃东西，否则你必须先刷牙。在编码中，我们为此目的使用条件语句。条件语句是 if、else、else-if 和 switch。在开始编码时，if-else和switch是您首先学习的东西之一。因此，了解两者之间的优点和区别非常重要。这就是我们将在本文中介绍的内容。在我们的日常生活中，我们总是通过使用 if-else 来决定事情。例如，让我们考虑一种情况，我们需要考虑每个月存在的天数。
使用 switch 重构嵌套 if-else 结构：简化代码逻辑
通过 switch 语句，我们可以避免编写大量的 if-else if-else 语句，提高代码的可读性和可维护性。switch 语句的基本语法包括一个表达式和多个 case 分支，每个 case 后跟要执行的代码块。在实际应用中，可以使用 ...
多分支条件下Switch为什么比if-else快
qq_36198826的博客
05-05 242
一、问题背景 在做语句块级别的动态插桩工具时，需要获取方法中的控制流信息，需要解析jvm指令。像for、while等循环，解除语法糖后会变成if、goto语句， 这其中比较难解析的是tableSwitch与lookupswitch指令，他们对应Java语法中的Switch语句。 二、指令分析 这两个字节码指令后都会跟0-3个nop空白填充，目的是为了让操作数能够4字节对齐 其中tableSwitch对齐填充后会跟三个32位有符号整数，即default地址、low值、high值。再然后会跟high-low+
汇编实现从1加到1000(《X86汇编语言 从实模式到保护模式(第2版》) 第135页第2题解答)
2401_85828611的博客
09-14 509
编写一段主引导扇区程序,计算从1加到1000的和,并在屏幕上显示结果。2.s3循环中,一定是保存完dx后再为dx清零。具体怎么将bin文件写入主引导扇区见此文。,否则新写入的数据会被覆盖!
linux命令find实现_find.zip
最新发布
09-17
linux命令find实现_find
基于ssm的高校信息资源共享平台设计与实现.docx
09-17
基于ssm的高校信息资源共享平台设计与实现.docx
吉他谱_Plush - Stone Temple Pilots.pdf
09-17
初级入门吉他谱 guitar tab
Java条件语句：if, if-else, 三元运算符与switch
"Java编程中的条件语句和循环语句是程序控制流程的重要组成部分，包括if、if-else、三元运算符以及for和while循环，特别是for循环的使用及其与while的区别。此外，还介绍了switch语句的特性和用法。" 在Java编程中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值