C++ Programming 3. Control Flow in C++ 13 mins read 19,506 views

C++ switch Statement: Case Selection, Flow, and Syntax

The switch statement in C++ is a selection statement that allows a program to choose one block of code from several alternatives. It checks the value of an expr...
Published: Nov 1, 2026Last Updated: Nov 21, 2026Curriculum: Class 12 / AP Physics / JEE-NEETReviewed by: OperateTools Editorial Board
Quick Summary & Direct Answer (AEO / GEO Extraction)

What is C++ switch Statement: Case Selection, Flow, and Syntax? The switch statement in C++ is a selection statement that allows a program to choose one block of code from several alternatives. It checks the value of an expr...

Audience & Scope: Students, educators, and candidates preparing for academic examinations and technical assessments in C++ Programming.
How does the switch statement evaluate integer and enum expressions with jump table optimizations in C++?
<p data-pm-slice="1 1 []">The <code dir="ltr">switch</code> statement in C++ is a selection statement that allows a program to choose one block of code from several alternatives. It checks the value of an expression and executes the matching <code dir="ltr">case</code> block.</p><p data-pm-slice="1 1 []"><br></p><p>For example, imagine creating a calculator with options for addition, subtraction, multiplication, and division. Instead of writing multiple <code dir="ltr">if-else</code> statements, you can use a <code dir="ltr">switch</code> statement to handle each choice.</p>

Explanation & In-Depth Details

<h2 class="h4 fw-bold text-dark mb-3"><span style="font-size: 1.15rem;">1. What Is the switch Statement in C++?</span></h2><p>The <code>switch</code> statement is used when you need to select one option from multiple possible values.</p><p>It evaluates an expression and compares its result with the values specified in different <code>case</code> labels.</p><p>When a matching case is found, execution begins from that case label.</p><p><strong>Main components of a switch statement:</strong></p><ul><li><p><code>switch</code>: Starts the selection structure.</p></li><li><p><code>case</code>: Defines a possible matching value.</p></li><li><p><code>break</code>: Exits the nearest enclosing loop or switch.</p></li><li><p><code>default</code>: Defines what to execute when no case matches.</p></li></ul><h2>2. Syntax of the switch Statement</h2><p>The basic syntax of a <code>switch</code> statement is:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">expression</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-id">value1</span><span class="js-op">:</span>
<span class="js-cm">// Statements</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-id">value2</span><span class="js-op">:</span>
<span class="js-cm">// Statements</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-id">value3</span><span class="js-op">:</span>
<span class="js-cm">// Statements</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">default</span><span class="js-op">:</span>
<span class="js-cm">// Statements</span>
<span class="js-op">}</span></code></pre></div><p><strong>How it works:</strong></p><ol start="1"><li><p>The switch expression is evaluated once.</p></li><li><p>Its value is compared with the case labels.</p></li><li><p>Execution starts at the matching case.</p></li><li><p>The statements continue until a <code>break</code> or the end of the switch body is reached.</p></li><li><p>If no case matches, the <code>default</code> block executes if one is provided.</p></li></ol><p>The expression must have an appropriate integral, enumeration, or class type that can be converted to an integral or enumeration type. Floating-point values and strings cannot be used directly as switch expressions in standard C++.</p><h2>3. Simple Example of switch in C++</h2><p>Let's create a simple program that displays the name of a day based on a number.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">day</span> <span class="js-op">=</span> <span class="js-num">3</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">day</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-num">1</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Monday"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">2</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Tuesday"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">3</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Wednesday"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">4</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Thursday"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">5</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Friday"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">default</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Invalid day"</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Wednesday</span></code></pre></div><p><strong>Explanation:</strong></p><ul><li><p>The variable <code>day</code> contains the value 3.</p></li><li><p>The switch statement compares 3 with each case value.</p></li><li><p><code>case 3</code> matches the expression.</p></li><li><p>The program prints <code>Wednesday</code>.</p></li><li><p>The <code>break</code> statement exits the switch block.</p></li></ul><h2>4. Understanding case Labels in C++</h2><p>A <code>case</code> label specifies a value that can match the switch expression.</p><p>Each case label must use a compile-time constant expression that can be converted to the type of the switch condition.</p><h3>Example: Different Case Values</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">number</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-num">10</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Number is 10"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">20</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Number is 20"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">30</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Number is 30"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Number</span> <span class="js-id">is</span> <span class="js-num">20</span></code></pre></div><p><strong>Important rules for case labels:</strong></p><ul><li><p>Case values must be constant expressions.</p></li><li><p>Duplicate case values are not allowed.</p></li><li><p>Case labels must be compatible with the switch expression type.</p></li><li><p>You cannot use ordinary variables as case values.</p></li></ul><p>For example, <code>case 10:</code> is valid, but <code>case number:</code> is invalid if <code>number</code> is an ordinary variable.</p><h2>5. Understanding the break Statement in switch</h2><p>The <code>break</code> statement is commonly used inside a switch block to prevent execution from continuing into the next case.</p><h3>Example: switch With break</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">choice</span> <span class="js-op">=</span> <span class="js-num">2</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">choice</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-num">1</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Apple"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">2</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Banana"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">3</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Orange"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Banana</span></code></pre></div><p>When <code>case 2</code> matches, the program prints <code>Banana</code> and then exits the switch because of <code>break</code>.</p><h3>What Happens Without break?</h3><p>If you leave out <code>break</code>, execution can continue into the statements of following cases. This behaviour is called <em>fall-through</em>.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-num">1</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">number</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-num">1</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"One"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">2</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Two"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">3</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Three"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">One</span>
<span class="js-id">Two</span>
<span class="js-id">Three</span></code></pre></div><p>The program starts executing at <code>case 1</code>. Because there are no <code>break</code> statements, it continues through the remaining case statements.</p><p>Fall-through can be intentional, but accidental fall-through is a common programming mistake.</p><h2>6. Understanding the default Case</h2><p>The <code>default</code> label specifies what happens when none of the case values matches the switch expression.</p><p>It is optional, but it is useful for handling unexpected or invalid input.</p><h3>Example: Using default</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">choice</span> <span class="js-op">=</span> <span class="js-num">8</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">choice</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-num">1</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Start"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">2</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Stop"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">3</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Pause"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">default</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Invalid choice"</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Invalid</span> <span class="js-id">choice</span></code></pre></div><p>Since the value 8 does not match any case, the <code>default</code> block executes.</p><p><strong>Remember:</strong></p><ul><li><p>A switch statement can have one <code>default</code> label.</p></li><li><p>The default label is optional.</p></li><li><p>It can appear anywhere inside the switch body.</p></li><li><p>It is commonly placed at the end for readability.</p></li></ul><h2>7. Using Multiple Cases for the Same Action</h2><p>Sometimes different case values need to execute the same block of code.</p><p>You can place multiple case labels together without adding statements between them.</p><h3>Example: Check Vowels</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">char</span> <span class="js-id">ch</span> <span class="js-op">=</span> <span class="js-str">'e'</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">ch</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-str">'a'</span><span class="js-op">:</span>
<span class="js-kw">case</span> <span class="js-str">'e'</span><span class="js-op">:</span>
<span class="js-kw">case</span> <span class="js-str">'i'</span><span class="js-op">:</span>
<span class="js-kw">case</span> <span class="js-str">'o'</span><span class="js-op">:</span>
<span class="js-kw">case</span> <span class="js-str">'u'</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Vowel"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">default</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Consonant"</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Vowel</span></code></pre></div><p><strong>Explanation:</strong></p><p>All five vowel cases lead to the same statements. If any one of them matches, the program prints <code>Vowel</code>.</p><p>This is a simple and clean way to handle multiple values with the same result.</p><h2>8. Using switch With Character Values</h2><p>A <code>switch</code> statement can also work with character values because characters have integral values in C++.</p><h3>Example: Character Selection</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">char</span> <span class="js-id">grade</span> <span class="js-op">=</span> <span class="js-str">'B'</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">grade</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-str">'A'</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Excellent"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-str">'B'</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Very Good"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-str">'C'</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Good"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-str">'D'</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Needs Improvement"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">default</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Invalid Grade"</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Very</span> <span class="js-id">Good</span></code></pre></div><p>The switch expression is the character <code>B</code>, so the matching case executes.</p><h2>9. Practical Example: Calculator Using switch</h2><p>A calculator is a common real-world example of a switch statement.</p><p>The user enters an operator and two numbers. The switch statement selects the appropriate mathematical operation.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">double</span> <span class="js-id">num1</span><span class="js-op">,</span> <span class="js-id">num2</span><span class="js-op">;</span>
<span class="js-id">char</span> <span class="js-id">op</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Enter first number: "</span><span class="js-op">;</span>
<span class="js-id">cin</span> <span class="js-op">&gt;&gt;</span> <span class="js-id">num1</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Enter operator (+, -, *, /): "</span><span class="js-op">;</span>
<span class="js-id">cin</span> <span class="js-op">&gt;&gt;</span> <span class="js-id">op</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Enter second number: "</span><span class="js-op">;</span>
<span class="js-id">cin</span> <span class="js-op">&gt;&gt;</span> <span class="js-id">num2</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">op</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-str">'+'</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Result: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">num1</span> <span class="js-op">+</span> <span class="js-id">num2</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-str">'-'</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Result: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">num1</span> <span class="js-op">-</span> <span class="js-id">num2</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-str">'*'</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Result: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">num1</span> <span class="js-op">*</span> <span class="js-id">num2</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-str">'/'</span><span class="js-op">:</span>
<span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">num2</span> <span class="js-op">!=</span> <span class="js-num">0</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Result: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">num1</span> <span class="js-op">/</span> <span class="js-id">num2</span><span class="js-op">;</span>
<span class="js-op">}</span> <span class="js-kw">else</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Error: Division by zero"</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">default</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Invalid operator"</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Sample Input:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Enter</span> <span class="js-id">first</span> <span class="js-id">number</span><span class="js-op">:</span> <span class="js-num">20</span>
<span class="js-id">Enter</span> <span class="js-id">operator</span> <span class="js-op">(+,</span> <span class="js-op">-,</span> <span class="js-op">*,</span> <span class="js-op">/):</span> <span class="js-op">*</span>
<span class="js-id">Enter</span> <span class="js-id">second</span> <span class="js-id">number</span><span class="js-op">:</span> <span class="js-num">5</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Result</span><span class="js-op">:</span> <span class="js-num">100</span></code></pre></div><p><strong>Explanation:</strong></p><ul><li><p>The program reads two numbers and an operator.</p></li><li><p>The switch statement checks the operator.</p></li><li><p>The matching case performs the calculation.</p></li><li><p>The division case checks for division by zero.</p></li><li><p>The default block handles unsupported operators.</p></li></ul><h2>10. Using switch With enum in C++</h2><p>An enumeration (<code>enum</code>) is a user-defined type that represents a set of named integral constants.</p><p>Switch statements work naturally with enumerations.</p><h3>Example: Using enum for Traffic Signals</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">enum</span> <span class="js-id">TrafficLight</span> <span class="js-op">{</span>
<span class="js-id">RED</span><span class="js-op">,</span>
<span class="js-id">YELLOW</span><span class="js-op">,</span>
<span class="js-id">GREEN</span>
<span class="js-op">};</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">TrafficLight</span> <span class="js-id">signal</span> <span class="js-op">=</span> <span class="js-id">GREEN</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">signal</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-id">RED</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Stop"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-id">YELLOW</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Get Ready"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-id">GREEN</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Go"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Go</span></code></pre></div><p>The enumeration makes the code easier to read because meaningful names are used instead of unexplained numeric values.</p><h2>11. Nested switch Statements in C++</h2><p>A nested switch means placing one switch statement inside another switch statement.</p><p>This can be useful when a program needs to make a second selection based on the result of the first selection.</p><h3>Example: Main Menu and Submenu</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">menu</span> <span class="js-op">=</span> <span class="js-num">1</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">option</span> <span class="js-op">=</span> <span class="js-num">2</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">menu</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-num">1</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Main Menu"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">option</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-num">1</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Profile"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">2</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Settings"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">default</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Invalid option"</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">default</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Invalid menu"</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Main</span> <span class="js-id">Menu</span>
<span class="js-id">Settings</span></code></pre></div><p><strong>Explanation:</strong></p><ul><li><p>The outer switch checks the main menu selection.</p></li><li><p>The inner switch checks the submenu option.</p></li><li><p>The inner <code>break</code> exits the inner switch.</p></li><li><p>The outer <code>break</code> exits the outer switch.</p></li></ul><p>Each <code>break</code> exits only the nearest enclosing switch or loop.</p><h2>12. Difference Between switch and if-else in C++</h2><p>Both <code>switch</code> and <code>if-else</code> are selection statements, but they are useful in different situations.</p><table><tbody><tr><th>Feature</th><th>switch</th><th>if-else</th></tr><tr><td>Main purpose</td><td>Selects based on matching values</td><td>Selects based on conditions</td></tr><tr><td>Expression</td><td>Uses an integral or enumeration-based selection expression, with supported conversions</td><td>Can use Boolean conditions</td></tr><tr><td>Comparisons</td><td>Matches case values</td><td>Supports relational and logical operators</td></tr><tr><td>Range checking</td><td>Not directly supported</td><td>Supported</td></tr><tr><td>String comparison</td><td>Not directly supported for <code>std::string</code></td><td>Supported</td></tr><tr><td>Multiple alternatives</td><td>Uses case labels</td><td>Uses else-if branches</td></tr><tr><td>Best use</td><td>Menu choices and fixed options</td><td>Complex conditions and ranges</td></tr></tbody></table><h3>Example Using if-else</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">marks</span> <span class="js-op">=</span> <span class="js-num">85</span><span class="js-op">;</span>

<span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">marks</span> <span class="js-op">&gt;=</span> <span class="js-num">90</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Grade A"</span><span class="js-op">;</span>
<span class="js-op">}</span> <span class="js-kw">else</span> <span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">marks</span> <span class="js-op">&gt;=</span> <span class="js-num">75</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Grade B"</span><span class="js-op">;</span>
<span class="js-op">}</span> <span class="js-kw">else</span> <span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">marks</span> <span class="js-op">&gt;=</span> <span class="js-num">50</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Grade C"</span><span class="js-op">;</span>
<span class="js-op">}</span> <span class="js-kw">else</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Fail"</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Grade</span> <span class="js-id">B</span></code></pre></div><p>Here, <code>if-else</code> is more suitable because the program checks ranges of values rather than matching individual constant values.</p><h2>13. Limitations of the switch Statement</h2><p>The switch statement is useful, but it has some limitations:</p><ol start="1"><li><p>It does not directly support floating-point switch expressions.</p></li><li><p>It does not directly support strings such as <code>std::string</code>.</p></li><li><p>Case labels must be compile-time constant expressions.</p></li><li><p>Duplicate case values are not allowed.</p></li><li><p>It is not designed for checking ranges such as <code>marks &gt;= 80</code>.</p></li><li><p>A switch statement can become difficult to maintain if it contains too many cases and complex nested logic.</p></li></ol><p>For complex conditions, <code>if-else</code> or other appropriate control structures may be a better choice.</p><h2>14. Common Mistakes When Using switch in C++</h2><h3>Mistake 1: Forgetting break</h3><p>Without <code>break</code>, execution may continue into the next case.</p><p><strong>Solution:</strong> Add <code>break</code> when you want to stop after a matching case.</p><h3>Mistake 2: Using Duplicate Case Values</h3><p>Incorrect example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">number</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-num">1</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"One"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>

<span class="js-kw">case</span> <span class="js-num">1</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Another One"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>This produces a compilation error because the same case value appears twice.</p><h3>Mistake 3: Using Variables as Case Values</h3><p>Incorrect example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">option</span> <span class="js-op">=</span> <span class="js-num">2</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">option</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-id">option</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Selected"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>An ordinary variable cannot be used as a case label because case labels must be constant expressions.</p><h3>Mistake 4: Expecting switch to Compare Ranges</h3><p>Incorrect example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">marks</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-id">marks</span> <span class="js-op">&gt;=</span> <span class="js-num">80</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Good"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>A case label is not a general Boolean condition for range matching. Use <code>if-else</code> for range-based comparisons.</p><h3>Mistake 5: Using Strings Directly</h3><p>Incorrect example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">string</span> <span class="js-id">fruit</span> <span class="js-op">=</span> <span class="js-str">"Apple"</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">fruit</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-str">"Apple"</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Selected Apple"</span><span class="js-op">;</span>
<span class="js-kw">break</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Standard C++ does not support <code>std::string</code> as a switch expression. Use <code>if-else</code> comparisons or another suitable selection approach.</p><h2>15. Best Practices for Using switch in C++</h2><p>Follow these practices to write clean and maintainable switch statements:</p><ol start="1"><li><p>Use <code>switch</code> when comparing one expression against several fixed values.</p></li><li><p>Include a <code>default</code> case when unexpected values need to be handled.</p></li><li><p>Use <code>break</code> to prevent accidental fall-through.</p></li><li><p>Group multiple case labels when they share the same action.</p></li><li><p>Use meaningful enumeration names instead of unexplained numbers.</p></li><li><p>Keep each case block short and easy to understand.</p></li><li><p>Use <code>if-else</code> for ranges and complex logical conditions.</p></li><li><p>Test valid inputs, invalid inputs, and boundary cases.</p></li></ol><h2>16. Frequently Asked Questions (FAQs)</h2><h3>Q1. What is the switch statement in C++?</h3><p>The <code>switch</code> statement selects and executes a block of code based on the value of an expression. It is commonly used for menu systems and fixed choices.</p><h3>Q2. What is the purpose of case in C++?</h3><p>The <code>case</code> label defines a constant value that can match the switch expression. When a match is found, execution starts at that case.</p><h3>Q3. Is break mandatory in every switch case?</h3><p>No. It is not mandatory, but it is commonly used to prevent fall-through. You can intentionally omit it when multiple cases should share execution.</p><h3>Q4. What is the default case in C++?</h3><p>The <code>default</code> label defines the statements that execute when no case matches the switch expression. It is optional.</p><h3>Q5. Can we use strings in a switch statement?</h3><p>No. Standard C++ does not allow <code>std::string</code> directly as a switch expression. Use <code>if-else</code> or another selection method for string comparisons.</p><h3>Q6. Can we use multiple cases for one statement?</h3><p>Yes. You can place multiple case labels together and let them share the same statements.</p><h3>Q7. Can we use a switch statement inside another switch?</h3><p>Yes. C++ supports nested switch statements. Each switch has its own case labels and control flow.</p><h3>Q8. What is fall-through in a switch statement?</h3><p>Fall-through occurs when execution continues from one case into subsequent case statements because no <code>break</code> or other control transfer stops it.</p><h3>Q9. Can we use float in switch in C++?</h3><p>No. A floating-point value cannot be used directly as a switch expression in standard C++.</p><h3>Q10. Which is better: switch or if-else?</h3><p>Neither is always better. Use <code>switch</code> for fixed value selection and <code>if-else</code> for ranges, relational comparisons, and complex logical conditions.</p>

Code Example

#include <iostream>

enum class HttpStatus {
    OK = 200,
    NotFound = 404,
    InternalError = 500
};

void handleResponse(HttpStatus status) {
    switch (status) {
        case HttpStatus::OK:
            std::cout << "Request successful [200 OK]
";
            break;
        case HttpStatus::NotFound:
            std::cout << "Resource not located [404 Not Found]
";
            break;
        case HttpStatus::InternalError:
            std::cout << "Server crashed [500 Internal Error]
";
            break;
        default:
            std::cout << "Unknown HTTP status
";
            break;
    }
}

int main() {
    handleResponse(HttpStatus::OK);
    handleResponse(HttpStatus::NotFound);
    return 0;
}

Interview Question & Tips

Q: Why can floating point types (float/double) not be used in a switch statement?
A: Floating-point numbers have precision nuances (rounding representation errors) that make exact bitwise equality matches unreliable for compiler jump table generation.

Q: What is a jump table in compiler optimization?
A: A jump table is an array of memory addresses indexed directly by the switch value, enabling O(1) branch dispatch regardless of the number of cases.

Best Practices

1. Use `enum class` with `switch` statements to enforce type-safe branching.
2. Always handle all enum cases or provide a defensive `default:` handler.
3. Annotate intentional fall-through cases with `[[fallthrough]];` in C++17.
Academic Standards & Verified Citations

This study reference for C++ switch Statement: Case Selection, Flow, and Syntax is curated and verified against recognized curriculum benchmarks, peer-reviewed textbooks, and official technical documentation:

C++ Programming