.. highlight:: cpp

.. _lang-switchcase:

``switch``\ /\ ``case``
=======================

Like :ref:`if <lang-if>` statements, A ``switch`` statement controls
program flow by allowing you to specify different code that should be
executed under various cases.

The general syntax looks like this::

    switch (var) {
    case val1:
        // statements
        break;
    case val2:
        // statements
        break;
    ...
    default:
        // statements
    }

Where ``var`` is a variable whose value to investigate, and the
``val1``, ``val2`` after each ``case`` are constant values that
``var`` might be.

Description
-----------

A ``switch`` statement compares the value of a variable to the values
specified in ``case`` statements. When a ``case`` statement is found
whose value matches that of the variable, the code in that case
statement is run.

Here's a more concrete example::

      switch (var) {
      case 1:
          doThing1();
          break;
      case 2:
          doThing2();
          break;
      }
      afterTheSwitch();

In the above example, if ``var == 1``, then the code beginning on the
line after ``case 1`` gets executed.  That is, if ``var`` is one,
``doThing1()`` gets called first, and then the ``break`` statement is
executed.

The ``break`` keyword exits the ``switch`` statement, and is typically
used at the end of each ``case``.  Since there is a ``break`` at the
end of ``case 1``, the ``switch`` statement exits, and the next line
to be run is the one which calls ``afterTheSwitch()``.

Without a ``break``, the ``switch`` statement will continue executing
the following ``case`` expressions ("falling-through") until a
``break`` (or the end of the switch statement) is reached.  Let's
pretend the ``switch`` looked like this instead::

      switch (var) {
      case 1:
          doThing1();
          // no break statement anymore
      case 2:
          doThing2();
          break;
      }
      afterTheSwitch();

Now, if ``var`` is one, ``doThing1()`` gets executed like before.
However, without a ``break``, the code would continue to be executed
line-by-line, so ``doThing2()`` would be called next.  At this point,
a ``break`` has been reached, so the program continues by calling
``afterTheSwitch()``.  This is usually not what you want, which is why
each ``case`` usually has a ``break`` at the end.

.. _lang-switchcase-default:

Writing "``default:``" instead of a ``case`` statement allows you to
specify what to do if none of the ``case`` statements matches.  Having
a ``default`` is optional (you can leave it out), but if you have one,
it must appear after all of the ``case`` statements.  Let's add a
``default`` to the ``switch`` we've been discussing::

      switch (var) {
      case 1:
          doThing1();
          break;
      case 2:
          doThing2();
          break;
      default:
          doSomethingElse();
      }
      afterTheSwitch();

If ``var`` is one, then ``doThing1()`` gets called.  If ``var`` is
two, ``doThing2()`` gets called.  If ``var`` is anything else,
``doSomethingElse()`` gets called.  As stated above, a ``default`` is
optional.  If you're missing one and none of the ``case`` statements
match, the ``switch`` does nothing at all, as if it weren't there.

``switch`` statements are often used with an :ref:`enum <lang-enum>`
value as the variable to compare.  In this case, you can write down
all of the values the ``enum`` takes as ``case`` statements, and be
sure you've covered all the possibilities.

See also:
---------

- :ref:`if/else <lang-if>`

.. include:: cc-attribution.txt
