Does case-switch work like this?

Question

I came across a case-switch piece of code today and was a bit surprised to see how it worked. The code was:

switch (blah)
{
case a:
  break;
case b:
  break;         


        

Answer 1

This is called a fall-through.

It is exactly doing what you are seeing: several cases is going to execute same piece of code.

It is also convenient in doing extra processing for certain case, and some shared logic:

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

This is a typical use of fall-through in switch-case. In case of STARTING and STARTED, we need to do deallocateResources and change the status to STOPPED, but STARTING need some extra cleanup. By the above way, you can clearly present the 'common logic' plus extra logic in STARTING.

STOPPED, STOPPING and default are similar, all of them fall thru to default logic (which is ignoring).

It is not always a good way to code like this but if it is well used it can present the logic better.

Answer 2

Luckily for us, C++ doesn't depend on your imagination :-)

Think of the switch labels as "goto" labels, and the switch(blah) simply "goes to" the corresponding label, and then the code just flows from there.

Answer 3

Actually the switch statement works the way you observed. It is designed so that you can combine several cases together until a break is encountered and it acts something like a sieve.

Here is a real-world example from one of my projects:

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

The code for KE_STRING and KE_VOIDPTR cases is identical except for the calculation of size in case of string.

Answer 4

That is the correct behavior, and it is referred to as "falling through". This lets you have multiple cases handled by the same code. In advanced situations, you may want to perform some code in one case, then fall through to another case.

Contrived example:

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 5

This is called case fall-through, and is a desirable behavior. It allows you to share code between cases.

An example of how to use case fall-through behavior:

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

If you enter the switch when blah == a, then you will execute function1(), function2(), and function3().

If you don't want to have this behavior, you can opt out of it by including break statements.

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

The way a switch statement works is that it will (more or less) execute a goto to jump to your case label, and keep running from that point. When the execution hits a break, it leaves the switch block.