switch(1) 
{
    case 1 : cout << '1'; // prints "1",
    case 2 : cout << '2'; // then prints "2"
}

switch(1) 
{
    case 1 : cout << '1'; break; // prints "1" and exits the switch
    case 2 : cout << '2'; break;        
}

case 1,3,5..8 :

switch (var)
{
case VALUE1: DoSomethingFor1();
case VALUE2: DoSomethingFor1And2();
    break;

case VALUE3: DoSomethingFor3();
default: DoSomethingFor3AndEverythingElse();
}

void commit_records_or_die(int how, const record *recs, size_t count)
{
size_t i;
struct stat s;
const record *tmp;

switch (how)
{
case OVERWRITE: 
    ftruncate(fd, 0);
    lseek(f, 0, SEEK_END);

case APPEND:
    for (i = 0; i<count; ++i)
    {
      if (write(fd, recs + i, sizeof(*rec))<=0) break;
    }
    if (i==count) break;
    fstat(fd, &s);
    ftruncate(f, s.st_size - i * sizeof(*recs));
    lseek(f, 0, SEEK_END);

case POSTPONE:
    tmp = realloc(global_postponed_records, (global_postponed_count + count) * sizeof(*recs));
    if (!tmp) abort();
    memcpy(tmp + global_postponed_count, recs, count * sizeof(*recs));
    global_postponed_count+= count;
    global_postponed_records = tmp;
    break;

 default:
  printf("don't know how: 0x%x\n", how);
}

ARK>Какую кучу функций? Функций должно быть столько, сколько надо.

ARK>void DoFullWork()
ARK>{
ARK>    checkLastWork();
ARK>    clearTemp();
ARK>    DoOptimizedWork();
ARK>}

ARK>void DoOptimizedWork()
ARK>{
ARK>    ClearCaches();
ARK>    DoWork();
ARK>}

ARK>void DoWork()
ARK>{
ARK>    ...
ARK>}
ARK>

void DoFullWork()
{
    checkLastWork();
    clearTemp();
    DoOptimizedWork();
}

void DoOptimizedWork()
{
    ClearCaches();
    DoWork();
}

void DoWork()
{
    ...
}

int main()
{
    someFlagEnum flag = getFlag();
    if(flag==doFullWork)      { DoFullWork(); }
        if(flag==doOptimizedWork) { DoOptimizedWork(); }
        if(flag==justDoIt)        { DoWork(); }
}

switch(getFlag())
{
    case doFullWork:      { checkLastWork(); clearTemp(); }
    case doOptimizedWork: { clearCaches(); }
    case justDoIt:        { doWork(); }
}

ARK>UPD. Сейчас посмотрел, в Java и JavaScript break необязателен, хотя мне казалось, что был обязателен. Теперь я знаю 4 языка с таким оператором.

    function sw(val)
    {
      $( "#dd" ).append( "without break. val: " + val + "<br />---<br />" );
      switch(val)
      {
        case 1: { $( "#dd" ).append( "case 1<br />" ); }
        case 2: { $( "#dd" ).append( "case 2<br />" ); }
        case 3: { $( "#dd" ).append( "case 3<br />" ); }
      }
      $( "#dd" ).append( "-----------------------------<br />" );
    }
    
    function swb(val)
    {
      $( "#dd" ).append( "with break. val: " + val + "<br />---<br />" );
      switch(val)
      {
        case 1: { $( "#dd" ).append( "case 1<br />" ); break; }
        case 2: { $( "#dd" ).append( "case 2<br />" ); break; }
        case 3: { $( "#dd" ).append( "case 3<br />" ); break; }
      }
      $( "#dd" ).append( "-----------------------------<br />" );
    }
    
    for (i=1; i<=3; i++)
    {
    sw(i);
    swb(i);
    }

__>но в си оказалось, что эта конструкция закреплена за совсем другой семантикой. вот и высказываю свое удивление и недовольство

swicth(a) {
    case 1: x = 1001; break;
    case 2: x = 4002; break;
};

__>switch(1) 
__>{
__>    case 1 : cout << '1'; // prints "1",
__>    case 2 : cout << '2'; // then prints "2"
__>}
__>

__>switch(1) 
__>{
__>    case 1 : cout << '1'; break; // prints "1" and exits the switch
__>    case 2 : cout << '2'; break;        
__>}
__>

switch(1) {
    case 1:
    case 2:
    case 3:
    case 4:
        std::cout << '1';
    default: break;
}
// prints 1

__>> я теперь уже знаю, что это разный код. вы спрашивали, зачем мне захотелось отказаться от break, вот я вам и привел пример, как выглядит текст с брейком и без оного.

swith(a)
{
case 1: res = 1001;
case 2: res = 4002;
};

// вместо
p->member = N;
// писал
T tmp = *p;
tmp.member = N;
*p = tmp;

#include <stdio.h>
main() /* подсчет цифр, символов-разделителей и прочих символов */
{
    int c, i, nwhite, nother, ndigit[10];
    nwhite = nother = 0;
    for (i = 0; i < 10; i++)
        ndigit[i] = 0;
    while ((с = getchar()) != EOF) {
        switch (c) {
        case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
            ndigit[c - '0']++;
        case ' ', '\n', '\t':
            nwhite++;
        default:
            nother++;
        }
    }
    printf ("цифр =");
    for (i = 0; i < 10; i++)
        printf (" %d", ndigit[i]);
    printf(", символов-разделителей = %d, прочих = %d\n",
            nwhite, nother);
    return 0;
}

X>Что тут не очевидного ?

X>switch(1) {
X>    case 1:
X>    case 2:
X>    case 3:
X>    case 4:
X>        std::cout << '1';
X>    default: break;
X>}
X>// prints 1
X>

goto (label_1) {
    lalel_1:
    label_2:
    label_3:
    label_4:
        std::cout << '1';
    break;
}
// prints 1

S>>Как по мне, так тут всё чётко понятно как код исполняться будет. goto в этом отношении даёт возможность выстрелить себе в ногу, а switch нет

ARK>Не дает? Ну-ну. В действительности здесь прямо-таки раздолье для стрельбы по ногам. Позже постараюсь нарыть ссылку про ошибку в маршрутизаторе, написанном на С, из-за пропущенного break в свитче, приведшую к параличу линии связи. Сейчас не могу вспомнить, где читал.

if(val=15) {}

if (can())
  do();
  do_hast();
  do_hast_mich();

if (can());
  do();

if (a && b) { ... }

/** nonsence.h **/

#if defined(_ONE_)

#    define CONST_A  (1)
// ...
#    define CONST_B  (2)
#    define CONST_C  (3)
// ...
#    define CONST_D  (1)   /* Hello ! */

#else

#    define CONST_A  (1)
// ...
#    define CONST_B  (2)
#    define CONST_C  (3)
// ...
#    define CONST_D  (4)   /* OK */

#endif

#include "nonsence.h"

int main()
{
    //...
    switch (X)
    {
        case (CONST_A, CONST_B):    // 1 or 2
            foo();
            break;
        case (CONST_C, CONST_D):    // 3 or 1
            bar();
            break;
        case ((CONST_A & CONST_B) | (CONST_C & CONST_D) ):
            blah_blah();
            break;
        default:
            //...
    }
    // ...
    return (0);
}

switch(3) 
{
   case 1: // пропускает, ибо 1 != 3
   case 2: // пропускает, ибо 2 != 3
   case 3: // входит, ибо 3 == 3
   case 4: // wtf?? 4!=3, а он все равно входит
   case 5: // wtf?? 5!=3, а он все равно входит  
};

switch (1) {
    case 1: std::cout << '1';
    case 2: std::cout << '2';
}

switch (1) {
    case 1:
    case 2: 
        std::cout << '1';
        std::cout << '2';
}

__>>так поэтому я и обратил на эту штуку внимание только сейчас, после долгих лет знакомства, ибо всегда и всюду автоматом включался break, который делал семантику естественной. а тут решил сэкономить в угоду читабельности, и на тебе — "все, что вы знали о switch — неправда" . потому и предупреждаю других граждан

swicth(a)
{
case 1: x = 1001; break;
case 2: x = 4002; break;
};

swicth(a)
{
case 1: x = 1001; 
case 2: x = 4002; 
};

TB>>case 1,3,5..8 :
TB>>

MD>Запятая уже занята для других целей

case {1,3,5..8} :

__>swicth(a)
__>{
__>case 1: x = 1001; break;
__>case 2: x = 4002; break;
__>};

__>swicth(a)
__>{
__>case 1: x = 1001; 
__>case 2: x = 4002; 
__>};
__>

int get_x_from_a(int a)
{
    switch (a)
    {
    case 1: return 1001;
    case 2: return 4002;
    // и т.д.
    };
}

__>>безусловно, но использовать более одного return — это моветон

wiki/Return_statement
Languages with an explicit return statement create the possibility of multiple return statements in the same function. Whether or not that is a good thing is controversial.

Strong adherents of structured programming make sure each function has a single entry and a single exit (SESE). It has thus been argued[6] that one should eschew the use of the explicit return statement except at the textual end of a subroutine, considering that, when it is used to "return early", it may suffer from the same sort of problems that arise for the GOTO statement.

__>switch(1) 
__>{
__>    case 1 : cout << '1'; // prints "1",
__>    case 2 : cout << '2'; // then prints "2"
__>}
__>

__>switch(1) 
__>{
__>    case 1 : cout << '1'; break; // prints "1" and exits the switch
__>    case 2 : cout << '2'; break;        
__>}
__>

#define SCASE_CONTINUE(x) case x:
#define SCASE(x, func) case x: func(); break
#define SCASEARG(x, func) case x: func(x); break
#define SDEFAULT() default: break

// example
void printX() {
    std::cout << "in god we trust!" << std::endl; // C++
}
void printArg(int arg) {
    std::cout << std::to_string(arg) << std::endl; // C++
}
int main() {
    int x = 1;
    switch (x) {
        SCASE_CONTINUE(1);
        SCASE_CONTINUE(2);
        SCASE_CONTINUE(3);
        SCASE(4, printX);
        SCASE(5, printX);
        SCASEARG(10, printArg);
        SDEFAULT();
    }
}

__>вот и я так ожидал, что "for отличается от while как switch от if/else", то есть, что первое является разновидностью синтаксического сахара второго (ведь for(<stat>_0; <condition>; <stat>_1){<body>} равносильно <stat>_0; while(<condition>){<body>; <stat>_1} ), а оказалось все не так

for (;;)

__>ну, как бы да, для меня это пример из области программирования на "высокоуровневом ассемблере".

bool get_fileext(char *dst, size_t len, const char *src)
{    
    for ( len = (src = strrchr(src, '.') ) ? len : 0; (len > 1 && !!(*dst=*src)); --len,++src,++dst);
    *dst = 0;
    return !*src;
}

__>вот, честно, даже в голову не приходит, каким боком там должна проскакивать тема swith (и зачем вообще while(false)? может, while(true) для бесконечного цикла?)

do                          //  switch(data)
{                           //  {
    if ( data == 1 )        //      case 1:
    {                       //  
        cout << '1';        //        cout << '1';
        break;              //      break;
    }                       //  
    if ( data == 2 )        //      case 2:
    {                       //  
        cout << '2';        //        cout << '2';
        break;              //      break;
    }                       //  
    ...                     //  
    if ( data == 3 )        //      case 3:
    {                       // 
        cout << '3';        //        cout << '3';
        break;              //      break;
    }                       // 
}                           //  }
while(false);               //

__>>вот, честно, даже в голову не приходит, каким боком там должна проскакивать тема swith (и зачем вообще while(false)? может, while(true) для бесконечного цикла?)

BFE>do                          //  switch(data)
BFE>{                           //  {
BFE>    if ( data == 1 )        //      case 1:
BFE>    {                       //  
BFE>        cout << '1';        //        cout << '1';
BFE>        break;              //      break;
BFE>    }                       //  
BFE>    if ( data == 2 )        //      case 2:
BFE>    {                       //  
BFE>        cout << '2';        //        cout << '2';
BFE>        break;              //      break;
BFE>    }                       //  
BFE>    ...                     //  
BFE>    if ( data == 3 )        //      case 3:
BFE>    {                       // 
BFE>        cout << '3';        //        cout << '3';
BFE>        break;              //      break;
BFE>    }                       // 
BFE>}                           //  }
BFE>while(false);               //
BFE>

bool bDone = false;
 
do {
    if ( data == 1)
    {
        cout << '1';
        bDone = true;
    }
    else
    if ( data == 2)
    {
         cout << '2';
         bDone = true;
    }
    else
    ...
    if ( data == 3)
    {
        cout << '3';
        bDone = true;
    }
}
while(!bDone);

for (;;)

__>а по мне, так while(true) более естественно выглядит, чем пустое условие в for (;)

switch (var)
{
    case 1:
        if(something1a()) break;
        if(something1b()) break;
        if(something1c()) break;
                something1();
        break;
    case 2:
        if(something2a()) break;
        if(something2b()) break;
        if(something2c()) break;
                something2();
        break;
}

bool get_fileext(char *dst, size_t len, const char *src)
O>>{    
O>>    for ( len = (src = strrchr(src, '.') ) ? len : 0; (len > 1 && !!(*dst=*src)); --len,++src,++dst);
O>>    *dst = 0;
O>>    return !*src;
O>>}

switch(flag)
{
    case doFullWork:      { checkLastWork(); clearTemp(); }
    case doOptimizedWork: { clearCaches(); }
    case justDoIt:        { doWork(); }
}