Il case-switch funziona così?

Question

Oggi mi sono imbattuto in un pezzo di codice del caso-switch e sono rimasto un po 'sorpreso nel vedere come funzionava. Il codice era:

switch (blah) 
{ 
case a: 
    break; 
case b: 
    break; 
case c: 
case d: 
case e: 
    { 
    /* code here */ 
    } 
    break; 
default : 
    return; 
} 

Con mia sorpresa nello scenario in cui la variabile è stata c, il percorso è andato all'interno del segmento "qui il codice". Sono d'accordo che non vi è alcuna interruzione alla fine della parte c dell'interruttore del caso, ma avrei immaginato che passasse invece da default. Quando atterri su una linea case blah:, non controlla se il tuo valore attuale corrisponde al caso specifico e solo allora ti lascia nel segmento specifico? Altrimenti qual è il punto di avere un caso?

Answer 1

Questo è chiamato caso caduta-through, ed è un comportamento desiderabile. Ti permette di condividere il codice tra i casi.

Un esempio di come utilizzare caso autunno-through comportamento:

switch(blah) 
{ 
case a: 
    function1(); 
case b: 
    function2(); 
case c: 
    function3(); 
    break; 
default: 
    break; 
} 

Se si inserisce l'interruttore quando blah == a, allora si eseguirà function1(), function2() e function3().

Se non si desidera avere questo comportamento, è possibile disattivarlo includendo le istruzioni break.

switch(blah) 
{ 
case a: 
    function1(); 
    break; 
case b: 
    function2(); 
    break; 
case c: 
    function3(); 
    break; 
default: 
    break; 
} 

Il modo un'istruzione switch funziona è che sarà (più o meno) eseguire un goto di saltare all'etichetta caso, e continuare a correre da quel punto. Quando l'esecuzione raggiunge lo break, lascia il blocco di commutazione.

Answer 2

Questo è il comportamento corretto ed è denominato "caduta attraverso". Ciò consente di avere più casi gestiti dallo stesso codice. In situazioni avanzate, potresti voler eseguire del codice in un caso, quindi passare a un altro caso.

esempio forzato:

switch(command) 
{ 
    case CMD_SAVEAS: 
    { 
     this->PromptForFilename(); 
    } // DO NOT BREAK, we still want to save 
    case CMD_SAVE: 
    { 
     this->Save(); 
    } break; 


    case CMD_CLOSE: 
    { 
     this->Close(); 
    } break; 

    default: 
     break; 
} 

Answer 3

Fortunatamente per noi, C++ non dipende dalla vostra immaginazione :-)

Pensate delle etichette degli interruttori come etichette "Vai a", e il switch(blah) semplicemente "va a" l'etichetta corrispondente, e quindi il codice scorre da lì.

Answer 4

In realtà la dichiarazione dell'interruttore funziona come osservato. È progettato in modo da poter combinare più casi insieme fino a quando si verifica un'interruzione e agisce come un setaccio.

Ecco un esempio reale da uno dei miei progetti:

struct keystore_entry *new_keystore(p_rsd_t rsd, enum keystore_entry_type type, const void *value, size_t size) { 
     struct keystore_entry *e; 
     e = rsd_malloc(rsd, sizeof(struct keystore_entry)); 
     if (!e) 
       return NULL; 
     e->type = type; 
     switch (e->type) { 
     case KE_DOUBLE: 
       memcpy(&e->dblval, value, sizeof(double)); 
       break; 
     case KE_INTEGER: 
       memcpy(&e->intval, value, sizeof(int)); 
       break; 

     /* NOTICE HERE */ 

     case KE_STRING: 
       if (size == 0) { 
         /* calculate the size if it's zero */ 
         size = strlen((const char *)value); 
       } 
     case KE_VOIDPTR: 
       e->ptr = rsd_malloc(rsd, size); 
       e->size = size; 
       memcpy(e->ptr, value, size); 
       break; 

     /* TO HERE */ 
     default: 
       return NULL; 
     } 
     return e; 
} 

Il codice per KE_STRING e KE_VOIDPTR casi è identico tranne che per il calcolo delle dimensioni in caso di stringa.

Answer 5

Questo è chiamato un fall-through.

Fa esattamente ciò che si sta vedendo: diversi casi eseguiranno lo stesso codice.

E 'anche conveniente nel fare elaborazione aggiuntiva per alcuni casi, e una logica comune:

// psuedo code: 
void stopServer() { 
    switch (serverStatus) 
    case STARTING: 
    { 
     extraCleanUpForStartingServer(); 
     // fall-thru 
    } 
    case STARTED: 
    { 
     deallocateResources(); 
     serverStatus = STOPPED; 
     break; 
    } 
    case STOPPING: 
    case STOPPED: 
    default: 
     // ignored 
     break; 
} 

Questo è un uso tipico della caduta-through in switch-case. In caso di STARTING e STARTED, dobbiamo fare deallocateResources e cambiare lo stato in STOPPED, ma STARTING ha bisogno di una pulizia extra. In questo modo, è possibile presentare chiaramente la "logica comune" più logica aggiuntiva in STARTING.

FERMO, ARRESTO e predefinito sono simili, tutti rientrano attraverso alla logica di default (che è ignorando).

Non è sempre un buon modo per codificare come questo, ma se ben usato può presentare la logica meglio.