为什么我们必须使用中断开关？

谁决定（并基于什么概念）在每个语句中switch必须使用（多种语言）构造break？

我们为什么要写这样的东西：

switch(a)
{
    case 1:
        result = 'one';
        break;
    case 2:
        result = 'two';
        break;
    default:
        result = 'not determined';
        break;
}

（在PHP和JS中注意到这一点；可能有许多其他语言正在使用此语言）

如果switch是的替代选择if，为什么我们不能使用与相同的构造if？即：

switch(a)
{
    case 1:
    {
        result = 'one';
    }
    case 2:
    {
        result = 'two';
    }
    default:
    {
        result = 'not determined';
    }
}

据说这break阻止了当前块之后的块的执行。但是，是否有人真的遇到了需要执行当前块及其后续块的情况？我没有 对我来说，break一直在那里。在每个街区。在每个代码中。

C是最早使用switch这种形式的语句的语言之一，所有其他主要语言都从那里继承了该语句，主要是选择保留默认的C语义-他们要么没有想到更改它的优点，要么断定它们比保持每个人习惯的行为重要。

至于为什么以这种方式设计C，它可能源于C作为“便携式组件”的概念。该switch语句基本上是分支表的抽象，并且分支表也具有隐式下降，并且需要附加的跳转指令来避免它。

因此，基本上，C的设计人员还选择保留默认的汇编器语义。

因为switch不是if ... else这些语言中语句的替代方法。

通过使用switch，我们可以一次匹配多个条件，在某些情况下，我们将不胜感激。

例：

public Season SeasonFromMonth(Month month)
{
    Season season;
    switch (month)
    {
        case Month.December:
        case Month.January:
        case Month.February:
            season = Season.Winter;
            break;

        case Month.March:
        case Month.April:
        case Month.May:
            season = Season.Spring;
            break;

        case Month.June:
        case Month.July:
        case Month.August:
            season = Season.Summer;
            break;

        default:
            season = Season.Autumn;
            break;
    }

    return season;
}

在C的上下文中，这已经在Stack Overflow上被问到了：为什么switch语句设计为需要中断？

总结接受的答案，可能是一个错误。大多数其他语言可能都只跟在C之后。但是，诸如C＃之类的某些语言似乎已通过允许失败来解决此问题-但只有在程序员明确地这样说时，才能解决此问题（来源：上面的链接，我自己并不说C＃） 。

我将举一个例子。如果要列出一年中每个月的天数，很明显，有些月份有31、30和1 28/29。看起来像这样

switch(month) {
    case 4:
    case 6:
    case 9:
    case 11;
        days = 30;
        break;
    case 2:
        //Find out if is leap year( divisible by 4 and all that other stuff)
        days = 28 or 29;
        break;
    default:
        days = 31;
}

这是一个示例，其中多个案例具有相同的效果，并且全部组合在一起。显然有一个选择break关键字的原因，而不是 if ... else if构造的原因。

这里要注意的主要事情是，具有许多类似情况的switch语句不是if ... else if ... else if ... else每个情况，而是if（1、2、3） ...否则if（4,5,6）else ...

在两种情况下，可能会发生从一个案例到另一个案例的“失败”的情况-空案例：

switch ( ... )
{
  case 1:
  case 2:
    do_something_for_1_and_2();
    break;
  ...
}

和非空的情况

switch ( ... )
{
  case 1:
    do_something_for_1();
    /* Deliberately fall through */
  case 2:
    do_something_for_1_and_2();
    break;
...
}

尽管引用了Duff的设备，但第二种情况的合法实例很少且相差甚远，并且通常被编码标准禁止并在静态分析期间进行标记。在哪里找到它，通常是由于省略了break。

前者是完全明智和普遍的。

老实说，我认为没有理由需要breakand语言解析器知道一个空的case-body是一个失败，而一个非空的case是独立的。

遗憾的是，ISO C小组似乎更着重于向语言添加新的（不需要的）和定义错误的功能，而不是修复未定义的，未指定的或实现定义的功能，更不用说是不合逻辑的了。

不强行使用break可能会导致本来很难完成的许多事情。其他人则注意到分组案例，对于这些案例，有许多非平凡的案例。

迫切需要break不要使用的一种情况是Duff's Device。这用于“ 展开 ”循环，在该循环中可以通过限制所需的比较次数来加快操作速度。我相信，最初使用时允许使用的功能，以前使用完整的汇总循环过慢。在某些情况下，它以代码大小为代价来交换速度。

break如果案例包含任何代码，则最好使用适当的注释来代替。否则，有人会修复丢失的内容break并引入错误。

在C中，起源似乎是这样的，该switch语句的代码块不是特殊的构造。它是一个普通的代码块，就像if语句下的块一样。

switch ()
{
}

if ()
{
}

case和default是此块内的跳转标签，具体与关联switch。它们的处理方式与的正常跳转标签相同goto。这里有一个重要的特定规则：跳转标签几乎可以在代码中的任何位置出现，而不会中断代码流。

作为普通的代码块，它不必是复合语句。标签也是可选的。这些是switchC语言中的有效语句：

switch (a)
    case 1: Foo();

switch (a)
    Foo();

switch (a)
{
    Foo();
}

以C标准本身为例（6.8.4.2）：

switch (expr) 
{ 
    int i = 4; 
    f(i); 
  case 0: 
    i=17; 
    /*falls through into default code */ 
  default: 
    printf("%d\n", i); 
} 

在人工程序片段中，标识符为i的对象存在自动存储持续时间（在该块内），但从未初始化，因此，如果控制表达式的值为非零值，则对printf函数的调用将访问不确定的值。同样，无法调用函数f。

此外，default也是跳转标签，因此可以位于任何地方，而不必是最后一种情况。

这也解释了达夫的装置：

switch (count % 8) {
    case 0: do {  *to = *from++;
    case 7:       *to = *from++;
    case 6:       *to = *from++;
    case 5:       *to = *from++;
    case 4:       *to = *from++;
    case 3:       *to = *from++;
    case 2:       *to = *from++;
    case 1:       *to = *from++;
            } while(--n > 0);
}

为什么会失败？因为在代码正常块正常码流，下通到下面的语句是期待，就像你希望它在一个if代码块。

if (a == b)
{
    Foo();
    /* "Fall-through" to Bar expected here. */
    Bar();
}

switch (a)
{
    case 1: 
        Foo();
        /* Automatic break would violate expected code execution semantics. */
    case 2:
        Bar();
}

我的猜测是这样做的原因是易于实施。您不需要特殊的代码即可解析和编译switch块，而无需担心特殊的规则。您只需像解析其他任何代码一样解析它，只需关心标签和跳转选择。

所有这些有趣的后续问题是以下嵌套语句是否显示“完成”。或不。

int a = 10;

switch (a)
{
    switch (a)
    {
        case 10: printf("Done.\n");
    }
}

C标准对此予以关注（6.8.4.2.4）：

案例或默认标签只能在最接近的封闭switch语句中访问。

几个人已经提到了匹配多个条件的概念，这有时会非常有价值。但是，匹配多个条件的能力并不一定要求您对每个匹配的条件进行完全相同的操作。考虑以下：

switch (someCase)
{
    case 1:
    case 2:
        doSomething1And2();
        break;

    case 3:
        doSomething3();

    case 4:
        doSomething3And4();
        break;

    default:
        throw new Error("Invalid Case");
}

这里有两种不同的方式来匹配多个条件。在条件1和2的情况下，它们只是陷入了完全相同的代码图中，并且做着完全相同的事情。随着条件3和4，但是，虽然他们最终都通过调用doSomething3And4()，只有 3个电话doSomething3()。

回答您的两个问题。

为什么C需要休息？

它归结为Cs的“便携式汇编程序”。像这样的伪代码很常见：

    targets=(addr1,addr2,addr3);
    opt = 1  ## or 0 or 2
switch:
    br targets[opt]  ## go to addr2 
addr1:
    do 1stuff
    br switchend
addr2:
    do 2stuff
    br switchend
addr3
    do 3stuff
switchend:
    ......

switch语句旨在提供更高级别的类似功能。

我们有没有不间断的开关吗？

是的，这很普遍，并且有一些用例。

首先，您可能想在几种情况下采取相同的措施。为此，我们将箱子彼此堆叠：

case 6:
case 9:
    // six or nine code

状态机中另一个常见的用例是，在处理一个状态之后，我们立即要进入并处理另一个状态：

case 9:
    crashed()
    newstate=10;
case 10:
    claim_damage();
    break;

Break语句是一个跳转语句，允许用户在进行，执行，执行或执行时退出最近的封闭开关（针对您的情况）。就这么简单。

我认为以上所有内容（该线程的主要结果是，如果您要设计一种新语言），默认值是无需添加break语句，编译器将像对待该语句一样对待它。

如果您希望继续进行下一种情况的罕见情况-只需continue声明即可。

可以对此进行改进，以便仅在案例内使用大括号时才继续进行，这样具有多个案例的几个月来执行相同精确代码的示例始终可以正常工作，而无需使用continue。