¿Por qué la declaración de cambio fue diseñada para necesitar un descanso?

Dada una simple declaración de cambio

switch (int)
{
    case 1 :
    {
        printf("1\n");
        break;
    }

    case 2 : 
    {
        printf("2\n");
    }

    case 3 : 
    {
        printf("3\n");
    }
}

La ausencia de una declaración de interrupción en el caso 2 implica que la ejecución continuará dentro del código para el caso 3. Esto no es un accidente; Fue diseñado de esa manera. ¿Por qué se tomaron estas decisiones? ¿Qué beneficio ofrece esto en comparación con tener una ruptura semántica automática para los bloques? ¿Cuál fue la razón?

Muchas respuestas parecen centrarse en la capacidad de fracasar como la razón para requerir la breakdeclaración.

Creo que fue simplemente un error, debido en gran medida a que cuando se diseñó C no había tanta experiencia sobre cómo se usarían estas construcciones.

Peter Van der Linden expone el caso en su libro "Expert C Programming":

Analizamos las fuentes del compilador Sun C para ver con qué frecuencia se usaba la falla predeterminada. El front-end del compilador Sun ANSI C tiene 244 instrucciones de cambio, cada una de las cuales tiene un promedio de siete casos. La caída ocurre en solo el 3% de todos estos casos.

En otras palabras, el comportamiento normal del interruptor es incorrecto el 97% del tiempo. No es solo en un compilador, por el contrario, cuando se utilizó la falla en este análisis, a menudo fue para situaciones que ocurren con más frecuencia en un compilador que en otro software, por ejemplo, cuando compila operadores que pueden tener uno o dos operandos :

switch (operator->num_of_operands) {
    case 2: process_operand( operator->operand_2);
              /* FALLTHRU */

    case 1: process_operand( operator->operand_1);
    break;
}

La omisión de casos es tan ampliamente reconocida como un defecto que incluso hay una convención de comentarios especial, que se muestra arriba, que le dice a la pelusa "este es realmente uno de esos 3% de los casos en que se deseaba la falla".

Creo que fue una buena idea que C # requiriera una declaración de salto explícita al final de cada bloque de casos (al tiempo que permite que se apilen varias etiquetas de casos, siempre y cuando solo haya un bloque de declaraciones). En C # todavía puede hacer que un caso se caiga a otro, solo tiene que hacer que la caída sea explícita saltando al siguiente caso usando a goto.

Es una lástima que Java no aprovechó la oportunidad para romper con la semántica de C.

En muchos sentidos, c es solo una interfaz limpia para modismos de ensamblaje estándar. Al escribir el control de flujo impulsado por la tabla de salto, el programador tiene la opción de caer o saltar de la "estructura de control", y un salto requiere una instrucción explícita.

Entonces, c hace lo mismo ...

Para implementar el dispositivo de Duff, obviamente:

dsend(to, from, count)
char *to, *from;
int count;
{
    int n = (count + 7) / 8;
    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);
    }
}

Si los casos fueron diseñados para romperse implícitamente, entonces no podrías haber sufrido un fracaso.

case 0:
case 1:
case 2:
    // all do the same thing.
    break;
case 3:
case 4:
    // do something different.
    break;
default:
    // something else entirely.

Si el interruptor se diseñó para explotar implícitamente después de cada caso, no tendría elección. La estructura de la caja del interruptor se diseñó de la manera que debe ser más flexible.

Las declaraciones de caso en las declaraciones de un interruptor son simplemente etiquetas.

Al encender un valor, la instrucción switch hace esencialmente un Goto a la etiqueta con el valor coincidente.

Esto significa que el descanso es necesario para evitar pasar al código bajo la siguiente etiqueta.

En cuanto a la razón por la que se implementó de esta manera, la naturaleza de caída de una declaración de cambio puede ser útil en algunos escenarios. Por ejemplo:

case optionA:
    // optionA needs to do its own thing, and also B's thing.
    // Fall-through to optionB afterwards.
    // Its behaviour is a superset of B's.
case optionB:
    // optionB needs to do its own thing
    // Its behaviour is a subset of A's.
    break;
case optionC:
    // optionC is quite independent so it does its own thing.
    break;

Para permitir cosas como:

switch(foo) {
case 1:
    /* stuff for case 1 only */
    if (0) {
case 2:
    /* stuff for case 2 only */
    }
    /* stuff for cases 1 and 2 */
case 3:
    /* stuff for cases 1, 2, and 3 */
}

Piense en la casepalabra clave como una gotoetiqueta y es mucho más natural.

Elimina la duplicación de código cuando varios casos necesitan ejecutar el mismo código (o el mismo código en secuencia).

Dado que en el nivel del lenguaje ensamblador no le importa si se divide entre cada uno o no, no hay sobrecarga para los casos de caída, de todos modos, ¿por qué no permitirlos, ya que ofrecen ventajas significativas en ciertos casos?

Me encontré con un caso de asignación de valores en vectores a estructuras: tenía que hacerse de tal manera que si el vector de datos fuera más corto que el número de miembros de datos en la estructura, el resto de los miembros permanecerían en su valor predeterminado En ese caso, omitir breakfue bastante útil.

switch (nShorts)
{
case 4: frame.leadV1    = shortArray[3];
case 3: frame.leadIII   = shortArray[2];
case 2: frame.leadII    = shortArray[1];
case 1: frame.leadI     = shortArray[0]; break;
default: TS_ASSERT(false);
}

Como muchos han especificado aquí, es permitir que un solo bloque de código funcione para múltiples casos. Esto debería ser una ocurrencia más común para sus declaraciones de cambio que el "bloque de código por caso" que especifique en su ejemplo.

Si tiene un bloque de código por caso sin fall-through, tal vez debería considerar usar un bloque if-elseif-else, ya que eso parecería más apropiado.