1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
.. 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
|
