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

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.