¿Se supone que funciona el uso de if (0) para omitir un caso en un interruptor?

Tengo una situación en la que me gustaría que dos casos en una instrucción de cambio de C ++ cayeran en un tercer caso. Específicamente, el segundo caso pasaría al tercer caso, y el primer caso también pasaría al tercer caso sin pasar por el segundo caso.

Tuve una idea tonta, la probé y ¡funcionó! Envolví el segundo caso en un if (0) {... }. Se parece a esto:

#ifdef __cplusplus
#  include <cstdio>
#else
#  include <stdio.h>
#endif

int main(void) {
    for (int i = 0; i < 3; i++) {
        printf("%d: ", i);
        switch (i) {
        case 0:
            putchar('a');
            // @fallthrough@
            if (0) {        // fall past all of case 1 (!)
        case 1:
            putchar('b');
            // @fallthrough@
            }
        case 2:
            putchar('c');
            break;
        }
        putchar('\n');
    }
    return 0;
}

Cuando lo ejecuto, obtengo el resultado deseado:

0: ac
1: bc
2: c

Lo probé tanto en C como en C ++ (ambos con clang) e hizo lo mismo.

Mis preguntas son: ¿Es esto válido C / C ++? ¿Se supone que debe hacer lo que hace?

Sí, esto está permitido y hace lo que quiere. Para una switchdeclaración, el estándar C ++ dice :

las etiquetas de mayúsculas y minúsculas en sí mismas no alteran el flujo de control, que continúa sin obstáculos a través de dichas etiquetas. Para salir de un interruptor, vea romper.

[Nota 1: Por lo general, la subdeclaración que es objeto de un cambio es compuesta y las etiquetas de caso y defecto aparecen en las declaraciones de nivel superior contenidas dentro de la subdeclaración (compuesta), pero esto no es obligatorio. Las declaraciones pueden aparecer en la subenunciación de una declaración de cambio. - nota final]

Entonces, cuando ifse evalúa la declaración, el flujo de control procede de acuerdo con las reglas de una ifdeclaración, independientemente de las etiquetas de los casos que intervengan.

Sí, se supone que esto funciona. Las etiquetas de caso de una instrucción switch en C son casi exactamente como etiquetas goto (con algunas advertencias sobre cómo funcionan con instrucciones switch anidadas). En particular, ellos mismos no definen bloques para las declaraciones que usted considera que están "dentro del caso", y puede usarlos para saltar al medio de un bloque como lo haría con un goto. Al saltar a la mitad de un bloque, se aplican las mismas advertencias que con goto con respecto al salto sobre la inicialización de variables, etc.

Dicho esto, en la práctica probablemente sea más claro escribir esto con una declaración goto, como en:

    switch (i) {
    case 0:
        putchar('a');
        goto case2;
    case 1:
        putchar('b');
        // @fallthrough@
    case2:
    case 2:
        putchar('c');
        break;
    }

Como han mencionado otras respuestas, esto está técnicamente permitido por el estándar, pero es muy confuso y poco claro para los futuros lectores del código.

Esta es la razón por la que las switch ... casedeclaraciones generalmente deben escribirse con llamadas a funciones y no con mucho código en línea.

switch(i) {
case 0:
    do_zero_case(); do_general_stuff(); break;
case 1:
    do_one_case(); do_general_stuff(); break;
case 2:
    do_general_stuff(); break;
default:
    do_default_not_zero_not_one_not_general_stuff(); break;
}