Это правильное поведение, и оно называется «проваливается». Это позволяет обрабатывать несколько дел одним и тем же кодом. В сложных ситуациях может потребоваться выполнить некоторый код в одном случае, а затем перейти к другому.

Придуманный пример:

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;
}

Это называется провалом.

Это именно то, что вы видите: несколько случаев будут выполнять один и тот же кусок кода.

Также удобно выполнять дополнительную обработку для определенного случая и некоторую общую логику:

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

Это типичное использование провала в распределительном шкафу. В случае STARTING и STARTED нам нужно сделать deallocateResources и изменить статус на STOPPED, но для STARTING требуется дополнительная очистка. Таким образом, вы можете четко представить «общую логику» плюс дополнительную логику в ЗАПУСКЕ.

STOPPED, STOPPING и default одинаковы, все они относятся к логике по умолчанию (которая игнорируется).

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

К счастью для нас, C ++ не зависит от вашего воображения :-)

Думайте о метках переключателей как о метках «goto», а switch(blah)просто «идет» к соответствующей метке, и тогда код просто вытекает оттуда.

На самом деле оператор switch работает так, как вы заметили. Он спроектирован так, что вы можете объединить несколько случаев, пока не встретится разрыв, и он действует как сито.

Вот реальный пример из одного из моих проектов:

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;
}

Код для KE_STRINGи KE_VOIDPTRслучаев идентичен, за исключением расчета размера в случае строки.