What to put in a default label of a switch?

Question

Let's say I have an enumeration.

enum class ShapeName : char {TRIANGLE,CIRCLE,SQUARE};

and later I have a function like this:

void Function (ShapeName const shape){

    switch (shape){
        case ShapeName::TRIANGLE:
            DoSomething1();
            break;

        case ShapeName::CIRCLE:
            DoSomething2();
            break;

        case ShapeName::SQUARE: 
            DoSomething3();
            break;

        default:
            //THIS CODE BLOCK SHOULD NEVER BE EXECUTED!
    }

    return;
}

Although the default label should never be executed, I want to account for the potential bugs that may arise if a programmer adds another value to 'ShapeName' and it's not accounted for in the switch.
What would you recommended I do?

1. Assertions
I could use an assertion, but what am I asserting?

assert(false); //?

2. Exceptions
I could throw an exception, but I don't think that would be very good practice. I'm under the impression that exceptions are for run time events that can not be predicted because of certain environments.

3. Exits
I can just exit the program immediately with an error. That feels like the best idea, but I'm unsure if it's good practice. I thought the advantage of assertions was that you could turn them all off when you were ready ship the program. Then, all that assertion code would no longer exist.

---

Maybe there is another way that I'm not aware of. I do use a compiler flag that warns about unaccounted for values, but I still want to know what others recommend.

Answer 1

I like the idea of asserting with an informative message. Try this:

assert (!"The default case of so-so switch was reached.");

This always returns false, but provides a message you can use.

Edit:
I found the source I pulled this notion out of my memory from; it's in the following book:
C++ Coding Standards - 101 Rules and Guidelines

Answer 2

My preference for this specific case, where you're switching on an enum tag and handling all cases, is to leave out the default. That way, with any reasonable compiler, if someone adds a new tag to the enum and not to the switch, you'll get a compile-time warning about the tag not being handled in the switch.

Answer 3

I guess for me it would depend somewhat on what the DoSomething# methods do.

If it's going to cause a less graceful crash later you definitely want to interrupt runtime when this gets called with an explanation of "function called with invalid enum: enumName" or something to give the developer notification that they didn't update this switch statement, rather than leaving them wondering if something fails later.

Answer 4

Short answer: Use polymorphism to eliminate the problem.

Long answer: The easiest way to solve the root problem (i.e. How to prevent switch statements with missing entries?) would be to avoid using switch statements if there's a chance of entries being forgotten. Switch statements are useful in local contexts, but if the logic they represent is duplicated in multiple locations then there's a possibility of forgetting to update one and you're setting yourself up for runtime errors.

class Shape
{
    // functionality MUST be added for new shape types
    // or a compile error will occur
    virtual void DoSomething() const = 0;
};

void Function (Shape const & shape){
    return shape.DoSomething();
}

The switch statement may still be useful at the site of creation:

enum class ShapeName : char {TRIANGLE,CIRCLE,SQUARE};

unique_ptr< Shape > MakeShape (ShapeName const shape){
    switch (shape){
        case ShapeName::TRIANGLE:
            return unique_ptr< Shape >( new Triangle() );

        case ShapeName::CIRCLE:
            return unique_ptr< Shape >( new Circle() );

        case ShapeName::SQUARE: 
            return unique_ptr< Shape >( new Square() );
     }

     throw std::runtime_error();
     // or whichever option you prefer from the other answers
}

But that's the only place the logic exists. And even that can be improved upon with static polymorphism:

enum class ShapeName : char {TRIANGLE,CIRCLE,SQUARE,ELLIPSE};

template< ShapeName shape >
unique_ptr< Shape > MakeShape();

template<>
unique_ptr< Shape > MakeShape< ShapeName::TRIANGLE >()
{
    return unique_ptr< Shape >( new Triangle() );
}

template<>
unique_ptr< Shape > MakeShape< ShapeName::CIRCLE >()
{
    return unique_ptr< Shape >( new Circle() );
}

template<>
unique_ptr< Shape > MakeShape< ShapeName::SQUARE >()
{
    return unique_ptr< Shape >( new Square() );
}

int main()
{
    MakeShape< ShapeName::TRIANGLE >(); // okay

    MakeShape< ShapeName::ELLIPSE >(); // compile error
}

See Martin Folwer for more info.