C++ Programming 7. C++ Structures and Unions 13 mins read 19,405 views

Enumerations in C++: Defining Named Constant Values With enum

In C++, programs often work with a fixed set of related values. For example, an application may need to represent days of the week, months, traffic light signal...
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 Enumerations in C++: Defining Named Constant Values With enum? In C++, programs often work with a fixed set of related values. For example, an application may need to represent days of the week, months, traffic light signal...

Audience & Scope: Students, educators, and candidates preparing for academic examinations and technical assessments in C++ Programming.
How do scoped enumerations (enum class) provide type safety and avoid global name pollution in C++?
<p data-pm-slice="1 1 []">In C++, programs often work with a fixed set of related values. For example, an application may need to represent days of the week, months, traffic light signals, payment statuses, or user roles.</p><p data-pm-slice="1 1 []"><br></p><p>You could use integers or strings to represent these values, but doing so can make programs harder to understand and maintain.</p><p>C++ provides a feature called <strong>enumeration (</strong><code dir="ltr"><strong>enum</strong></code><strong>)</strong> that allows you to define a collection of named constant values.</p><p><br></p><p>For example, instead of writing <code dir="ltr">1</code>, <code dir="ltr">2</code>, and <code dir="ltr">3</code> to represent different order statuses, you can define meaningful names such as <code dir="ltr">Pending</code>, <code dir="ltr">Processing</code>, and <code dir="ltr">Completed</code>.</p>

Explanation & In-Depth Details

<h2 class="h4 fw-bold text-dark mb-3"><span style="font-size: 1.15rem;">1. What Is an Enumeration in C++?</span></h2><p>An enumeration is a user-defined type that represents a set of named constant values.</p><p>Each name is called an <em>enumerator</em>.</p><h3>Syntax</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">enum</span> <span class="js-id">EnumName</span> <span class="js-op">{</span>
<span class="js-id">VALUE1</span><span class="js-op">,</span>
<span class="js-id">VALUE2</span><span class="js-op">,</span>
<span class="js-id">VALUE3</span>
<span class="js-op">};</span></code></pre></div><p>Here:</p><ul><li><p><code>enum</code> is the keyword used to declare an enumeration.</p></li><li><p><code>EnumName</code> is the name of the enumeration type.</p></li><li><p><code>VALUE1</code>, <code>VALUE2</code>, and <code>VALUE3</code> are enumerators.</p></li><li><p>The semicolon after the closing brace is required.</p></li></ul><h3>Example: Declare an Enumeration</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">Day</span> <span class="js-op">{</span>
<span class="js-id">Monday</span><span class="js-op">,</span>
<span class="js-id">Tuesday</span><span class="js-op">,</span>
<span class="js-id">Wednesday</span><span class="js-op">,</span>
<span class="js-id">Thursday</span><span class="js-op">,</span>
<span class="js-id">Friday</span><span class="js-op">,</span>
<span class="js-id">Saturday</span><span class="js-op">,</span>
<span class="js-id">Sunday</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">Day</span> <span class="js-id">today</span> <span class="js-op">=</span> <span class="js-id">Wednesday</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">today</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>Output:</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-num">2</span></code></pre></div><p>By default, the first enumerator has the value <code>0</code>, and each following enumerator increases by one.</p><table><tbody><tr><th>Enumerator</th><th>Default value</th></tr><tr><td><code>Monday</code></td><td>0</td></tr><tr><td><code>Tuesday</code></td><td>1</td></tr><tr><td><code>Wednesday</code></td><td>2</td></tr><tr><td><code>Thursday</code></td><td>3</td></tr><tr><td><code>Friday</code></td><td>4</td></tr><tr><td><code>Saturday</code></td><td>5</td></tr><tr><td><code>Sunday</code></td><td>6</td></tr></tbody></table><p>The output is <code>2</code> because <code>Wednesday</code> has the underlying value <code>2</code>.</p><p>Although the value can be displayed as an integer, using meaningful enumerator names makes the program easier to read.</p><h2>2. Declaring and Initializing enum Variables</h2><p>After defining an enumeration, you can create variables of that type.</p><h3>Syntax</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">EnumName</span> <span class="js-id">variableName</span><span class="js-op">;</span></code></pre></div><p>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">enum</span> <span class="js-id">Color</span> <span class="js-op">{</span>
<span class="js-id">Red</span><span class="js-op">,</span>
<span class="js-id">Green</span><span class="js-op">,</span>
<span class="js-id">Blue</span>
<span class="js-op">};</span>

<span class="js-id">Color</span> <span class="js-id">selectedColor</span> <span class="js-op">=</span> <span class="js-id">Green</span><span class="js-op">;</span></code></pre></div><p>Here, <code>selectedColor</code> is an enumeration variable containing the value <code>Green</code>.</p><p>You can also assign another enumerator:</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">selectedColor</span> <span class="js-op">=</span> <span class="js-id">Blue</span><span class="js-op">;</span></code></pre></div><p>A traditional unscoped enum can also be declared and used directly:</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">enum</span> <span class="js-id">Status</span> <span class="js-op">{</span>
<span class="js-id">Pending</span><span class="js-op">,</span>
<span class="js-id">Approved</span><span class="js-op">,</span>
<span class="js-id">Rejected</span>
<span class="js-op">};</span>

<span class="js-id">Status</span> <span class="js-id">orderStatus</span> <span class="js-op">=</span> <span class="js-id">Pending</span><span class="js-op">;</span></code></pre></div><h2>3. Assigning Custom Values to Enumerators</h2><p>By default, enumerators receive consecutive integer values starting from zero. You can also assign your own values.</p><h3>Example</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">Level</span> <span class="js-op">{</span>
<span class="js-id">Low</span> <span class="js-op">=</span> <span class="js-num">1</span><span class="js-op">,</span>
<span class="js-id">Medium</span> <span class="js-op">=</span> <span class="js-num">5</span><span class="js-op">,</span>
<span class="js-id">High</span> <span class="js-op">=</span> <span class="js-num">10</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">Level</span> <span class="js-id">currentLevel</span> <span class="js-op">=</span> <span class="js-id">High</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Level value: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">currentLevel</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>Output:</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">Level</span> <span class="js-id">value</span><span class="js-op">:</span> <span class="js-num">10</span></code></pre></div><p>In this example:</p><ul><li><p><code>Low</code> has the value <code>1</code>.</p></li><li><p><code>Medium</code> has the value <code>5</code>.</p></li><li><p><code>High</code> has the value <code>10</code>.</p></li></ul><p>If an enumerator is not explicitly assigned a value, it normally receives one greater than the previous enumerator.</p><p>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">enum</span> <span class="js-id">Number</span> <span class="js-op">{</span>
<span class="js-id">First</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">,</span>
<span class="js-id">Second</span><span class="js-op">,</span>
<span class="js-id">Third</span><span class="js-op">,</span>
<span class="js-id">Fourth</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">,</span>
<span class="js-id">Fifth</span>
<span class="js-op">};</span></code></pre></div><p>The values are:</p><table><tbody><tr><th>Enumerator</th><th>Value</th></tr><tr><td><code>First</code></td><td>10</td></tr><tr><td><code>Second</code></td><td>11</td></tr><tr><td><code>Third</code></td><td>12</td></tr><tr><td><code>Fourth</code></td><td>20</td></tr><tr><td><code>Fifth</code></td><td>21</td></tr></tbody></table><h2>4. Using enum With switch Statements</h2><p>Enumerations work particularly well with <code>switch</code> statements because each enumerator represents a named option.</p><h3>Example: Display Days of the Week</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">Day</span> <span class="js-op">{</span>
<span class="js-id">Monday</span><span class="js-op">,</span>
<span class="js-id">Tuesday</span><span class="js-op">,</span>
<span class="js-id">Wednesday</span><span class="js-op">,</span>
<span class="js-id">Thursday</span><span class="js-op">,</span>
<span class="js-id">Friday</span><span class="js-op">,</span>
<span class="js-id">Saturday</span><span class="js-op">,</span>
<span class="js-id">Sunday</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">Day</span> <span class="js-id">today</span> <span class="js-op">=</span> <span class="js-id">Friday</span><span class="js-op">;</span>

<span class="js-kw">switch</span> <span class="js-op">(</span><span class="js-id">today</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">case</span> <span class="js-id">Monday</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Start of the working week"</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">Friday</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"End of the working week"</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">Saturday</span><span class="js-op">:</span>
<span class="js-kw">case</span> <span class="js-id">Sunday</span><span class="js-op">:</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Weekend"</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">"Regular working 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>Output:</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">End</span> <span class="js-kw">of</span> <span class="js-id">the</span> <span class="js-id">working</span> <span class="js-id">week</span></code></pre></div><p>The <code>switch</code> statement checks the enumeration value and executes the matching case.</p><p>Using named values is clearer than writing numeric case labels such as <code>0</code>, <code>1</code>, or <code>2</code>.</p><h2>5. Comparing enum Values</h2><p>You can compare values of the same enumeration type using comparison operators.</p><h3>Example</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">Priority</span> <span class="js-op">{</span>
<span class="js-id">Low</span><span class="js-op">,</span>
<span class="js-id">Medium</span><span class="js-op">,</span>
<span class="js-id">High</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">Priority</span> <span class="js-id">task</span> <span class="js-op">=</span> <span class="js-id">High</span><span class="js-op">;</span>

<span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">task</span> <span class="js-op">==</span> <span class="js-id">High</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">"High priority task"</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">"Other priority"</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>Output:</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">High</span> <span class="js-id">priority</span> <span class="js-id">task</span></code></pre></div><p>You can use operators such as:</p><ul><li><p><code>==</code> for equality.</p></li><li><p><code>!=</code> for inequality.</p></li><li><p><code>&lt;</code> for less than.</p></li><li><p><code>&gt;</code> for greater than.</p></li><li><p><code>&lt;=</code> for less than or equal to.</p></li><li><p><code>&gt;=</code> for greater than or equal to.</p></li></ul><p>These comparisons use the enumerators' underlying values. Use them only when the numeric ordering is meaningful for your application.</p><h2>6. What Is enum class in C++?</h2><p>C++11 introduced <strong>scoped enumerations</strong>, declared using <code>enum class</code> or <code>enum struct</code>.</p><p>They provide stronger type safety and avoid placing enumerator names directly into the surrounding scope.</p><h3>Syntax</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">enum</span> <span class="js-kw">class</span> <span class="js-id">EnumName</span> <span class="js-op">{</span>
<span class="js-id">VALUE1</span><span class="js-op">,</span>
<span class="js-id">VALUE2</span><span class="js-op">,</span>
<span class="js-id">VALUE3</span>
<span class="js-op">};</span></code></pre></div><h3>Example: Using enum class</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-kw">class</span> <span class="js-id">Color</span> <span class="js-op">{</span>
<span class="js-id">Red</span><span class="js-op">,</span>
<span class="js-id">Green</span><span class="js-op">,</span>
<span class="js-id">Blue</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">Color</span> <span class="js-id">selectedColor</span> <span class="js-op">=</span> <span class="js-id">Color</span><span class="js-op">::</span><span class="js-id">Green</span><span class="js-op">;</span>

<span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">selectedColor</span> <span class="js-op">==</span> <span class="js-id">Color</span><span class="js-op">::</span><span class="js-id">Green</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">"Green color selected"</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>Output:</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">Green</span> <span class="js-id">color</span> <span class="js-id">selected</span></code></pre></div><p>Notice the syntax:</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">Color</span><span class="js-op">::</span><span class="js-id">Green</span></code></pre></div><p>With <code>enum class</code>, you must qualify enumerators using the enumeration type name.</p><h3>Advantages of enum class</h3><ol start="1"><li><p>Provides stronger type safety.</p></li><li><p>Keeps enumerator names inside their enumeration scope.</p></li><li><p>Prevents implicit conversion to integers.</p></li><li><p>Reduces accidental name conflicts.</p></li><li><p>Makes code easier to understand in larger applications.</p></li></ol><p>For most new C++ code, <code>enum class</code> is generally the preferred choice.</p><h2>7. Difference Between enum and enum class</h2><p>Traditional unscoped enums and scoped enums have some important differences.</p><table><tbody><tr><th>Feature</th><th>enum</th><th>enum class</th></tr><tr><td>Introduced</td><td>Traditional C++</td><td>C++11</td></tr><tr><td>Enumerator scope</td><td>Surrounding scope</td><td>Enumeration scope</td></tr><tr><td>Implicit conversion to integer</td><td>Supported</td><td>Not supported</td></tr><tr><td>Type safety</td><td>Less restrictive</td><td>Stronger</td></tr><tr><td>Name conflicts</td><td>More likely</td><td>Less likely</td></tr><tr><td>Access syntax</td><td><code>Red</code></td><td><code>Color::Red</code></td></tr><tr><td>Underlying type</td><td>Implementation-selected integral type</td><td>Implementation-selected integral type</td></tr></tbody></table><h3>Example: Traditional enum</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">enum</span> <span class="js-id">Color</span> <span class="js-op">{</span>
<span class="js-id">Red</span><span class="js-op">,</span>
<span class="js-id">Green</span><span class="js-op">,</span>
<span class="js-id">Blue</span>
<span class="js-op">};</span>

<span class="js-id">Color</span> <span class="js-id">selected</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">value</span> <span class="js-op">=</span> <span class="js-id">selected</span><span class="js-op">;</span></code></pre></div><p>The conversion to <code>int</code> is allowed.</p><h3>Example: enum class</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">enum</span> <span class="js-kw">class</span> <span class="js-id">Color</span> <span class="js-op">{</span>
<span class="js-id">Red</span><span class="js-op">,</span>
<span class="js-id">Green</span><span class="js-op">,</span>
<span class="js-id">Blue</span>
<span class="js-op">};</span>

<span class="js-id">Color</span> <span class="js-id">selected</span> <span class="js-op">=</span> <span class="js-id">Color</span><span class="js-op">::</span><span class="js-id">Green</span><span class="js-op">;</span>

<span class="js-cm">// int value = selected; // Compilation error</span></code></pre></div><p>You must explicitly convert a scoped enumerator when an integer value is needed.</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">value</span> <span class="js-op">=</span> <span class="js-id">static_cast</span><span class="js-op">&lt;</span><span class="js-id">int</span><span class="js-op">&gt;(</span><span class="js-id">selected</span><span class="js-op">);</span></code></pre></div><h2>8. Specifying the Underlying Type of an Enumeration</h2><p>C++ allows you to specify the integral type used to represent an enumeration.</p><p>This is useful when you need a particular representation or a defined range.</p><h3>Syntax</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">enum</span> <span class="js-kw">class</span> <span class="js-id">EnumName</span> <span class="js-op">:</span> <span class="js-id">data_type</span> <span class="js-op">{</span>
<span class="js-id">VALUE1</span><span class="js-op">,</span>
<span class="js-id">VALUE2</span>
<span class="js-op">};</span></code></pre></div><h3>Example</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-kw">class</span> <span class="js-id">Status</span> <span class="js-op">:</span> <span class="js-id">unsigned</span> <span class="js-id">char</span> <span class="js-op">{</span>
<span class="js-id">Pending</span> <span class="js-op">=</span> <span class="js-num">1</span><span class="js-op">,</span>
<span class="js-id">Approved</span> <span class="js-op">=</span> <span class="js-num">2</span><span class="js-op">,</span>
<span class="js-id">Rejected</span> <span class="js-op">=</span> <span class="js-num">3</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">Status</span> <span class="js-id">current</span> <span class="js-op">=</span> <span class="js-id">Status</span><span class="js-op">::</span><span class="js-id">Approved</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">static_cast</span><span class="js-op">&lt;</span><span class="js-id">int</span><span class="js-op">&gt;(</span><span class="js-id">current</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>Output:</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-num">2</span></code></pre></div><p>Here, <code>unsigned char</code> is the specified underlying type.</p><p>The explicit conversion is needed because <code>enum class</code> values do not automatically convert to integers.</p><p>You can also specify an underlying type for a traditional enum:</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">enum</span> <span class="js-id">Status</span> <span class="js-op">:</span> <span class="js-id">unsigned</span> <span class="js-id">char</span> <span class="js-op">{</span>
<span class="js-id">Pending</span> <span class="js-op">=</span> <span class="js-num">1</span><span class="js-op">,</span>
<span class="js-id">Approved</span> <span class="js-op">=</span> <span class="js-num">2</span><span class="js-op">,</span>
<span class="js-id">Rejected</span> <span class="js-op">=</span> <span class="js-num">3</span>
<span class="js-op">};</span></code></pre></div><h2>9. Forward Declaration of an enum</h2><p>A scoped enumeration can be declared before its full definition, provided its underlying type is known or specified as required by the language rules.</p><h3>Example</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-kw">class</span> <span class="js-id">Status</span> <span class="js-op">:</span> <span class="js-id">int</span><span class="js-op">;</span>

<span class="js-kw">void</span> <span class="js-id">displayStatus</span><span class="js-op">(</span><span class="js-id">Status</span> <span class="js-id">value</span><span class="js-op">);</span>

<span class="js-id">enum</span> <span class="js-kw">class</span> <span class="js-id">Status</span> <span class="js-op">:</span> <span class="js-id">int</span> <span class="js-op">{</span>
<span class="js-id">Pending</span><span class="js-op">,</span>
<span class="js-id">Approved</span><span class="js-op">,</span>
<span class="js-id">Rejected</span>
<span class="js-op">};</span>

<span class="js-kw">void</span> <span class="js-id">displayStatus</span><span class="js-op">(</span><span class="js-id">Status</span> <span class="js-id">value</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">value</span> <span class="js-op">==</span> <span class="js-id">Status</span><span class="js-op">::</span><span class="js-id">Approved</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">"Approved"</span><span class="js-op">;</span>
<span class="js-op">}</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">displayStatus</span><span class="js-op">(</span><span class="js-id">Status</span><span class="js-op">::</span><span class="js-id">Approved</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>Output:</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">Approved</span></code></pre></div><p>Forward declarations are useful when organizing declarations across multiple source files or headers.</p><h2>10. Using enum for Bit Flags</h2><p>Enumerations can also represent sets of independent options using bit flags.</p><p>This is commonly done with scoped enumerations and bitwise operators.</p><h3>Example</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-kw">class</span> <span class="js-id">Permission</span> <span class="js-op">:</span> <span class="js-id">unsigned</span> <span class="js-id">int</span> <span class="js-op">{</span>
<span class="js-id">None</span> <span class="js-op">=</span> <span class="js-num">0</span><span class="js-op">,</span>
<span class="js-id">Read</span> <span class="js-op">=</span> <span class="js-num">1</span><span class="js-op">,</span>
<span class="js-id">Write</span> <span class="js-op">=</span> <span class="js-num">2</span><span class="js-op">,</span>
<span class="js-id">Execute</span> <span class="js-op">=</span> <span class="js-num">4</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">Permission</span> <span class="js-id">access</span> <span class="js-op">=</span>
<span class="js-id">static_cast</span><span class="js-op">&lt;</span><span class="js-id">Permission</span><span class="js-op">&gt;(</span>
<span class="js-id">static_cast</span><span class="js-op">&lt;</span><span class="js-id">unsigned</span> <span class="js-id">int</span><span class="js-op">&gt;(</span><span class="js-id">Permission</span><span class="js-op">::</span><span class="js-id">Read</span><span class="js-op">)</span> <span class="js-op">|</span>
<span class="js-id">static_cast</span><span class="js-op">&lt;</span><span class="js-id">unsigned</span> <span class="js-id">int</span><span class="js-op">&gt;(</span><span class="js-id">Permission</span><span class="js-op">::</span><span class="js-id">Write</span><span class="js-op">)</span>
<span class="js-op">);</span>

<span class="js-id">unsigned</span> <span class="js-id">int</span> <span class="js-id">flags</span> <span class="js-op">=</span> <span class="js-id">static_cast</span><span class="js-op">&lt;</span><span class="js-id">unsigned</span> <span class="js-id">int</span><span class="js-op">&gt;(</span><span class="js-id">access</span><span class="js-op">);</span>

<span class="js-kw">if</span> <span class="js-op">((</span><span class="js-id">flags</span> <span class="js-op">&amp;</span> <span class="js-id">static_cast</span><span class="js-op">&lt;</span><span class="js-id">unsigned</span> <span class="js-id">int</span><span class="js-op">&gt;(</span><span class="js-id">Permission</span><span class="js-op">::</span><span class="js-id">Read</span><span class="js-op">))</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">"Read permission enabled"</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">if</span> <span class="js-op">((</span><span class="js-id">flags</span> <span class="js-op">&amp;</span> <span class="js-id">static_cast</span><span class="js-op">&lt;</span><span class="js-id">unsigned</span> <span class="js-id">int</span><span class="js-op">&gt;(</span><span class="js-id">Permission</span><span class="js-op">::</span><span class="js-id">Write</span><span class="js-op">))</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">"Write permission enabled"</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">if</span> <span class="js-op">((</span><span class="js-id">flags</span> <span class="js-op">&amp;</span> <span class="js-id">static_cast</span><span class="js-op">&lt;</span><span class="js-id">unsigned</span> <span class="js-id">int</span><span class="js-op">&gt;(</span><span class="js-id">Permission</span><span class="js-op">::</span><span class="js-id">Execute</span><span class="js-op">))</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">"Execute permission enabled"</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>Output:</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">Read</span> <span class="js-id">permission</span> <span class="js-id">enabled</span>
<span class="js-id">Write</span> <span class="js-id">permission</span> <span class="js-id">enabled</span></code></pre></div><p>Each flag uses a different bit:</p><table><tbody><tr><th>Permission</th><th>Value</th><th>Binary representation</th></tr><tr><td>None</td><td>0</td><td>000</td></tr><tr><td>Read</td><td>1</td><td>001</td></tr><tr><td>Write</td><td>2</td><td>010</td></tr><tr><td>Execute</td><td>4</td><td>100</td></tr></tbody></table><p>The bitwise OR operation combines permissions. The bitwise AND operation checks whether a particular flag is present.</p><p>For larger applications, you can define overloaded bitwise operators to make flag handling easier to read.</p><h2>11. Using enum in Functions</h2><p>Enumeration values can be passed to functions like other variables.</p><h3>Example</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-kw">class</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-kw">void</span> <span class="js-id">displaySignal</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-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">TrafficLight</span><span class="js-op">::</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">TrafficLight</span><span class="js-op">::</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">TrafficLight</span><span class="js-op">::</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-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">displaySignal</span><span class="js-op">(</span><span class="js-id">TrafficLight</span><span class="js-op">::</span><span class="js-id">Green</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>Output:</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>Using an enumeration as a function parameter makes the expected set of values clear.</p><h2>12. Using enum in Structures and Classes</h2><p>Enumerations can be used as data members in structures and classes.</p><h3>Example: Employee Department</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">include</span> <span class="js-op">&lt;</span><span class="js-id">string</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-kw">class</span> <span class="js-id">Department</span> <span class="js-op">{</span>
<span class="js-id">HR</span><span class="js-op">,</span>
<span class="js-id">IT</span><span class="js-op">,</span>
<span class="js-id">Finance</span><span class="js-op">,</span>
<span class="js-id">Sales</span>
<span class="js-op">};</span>

<span class="js-id">struct</span> <span class="js-id">Employee</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">id</span><span class="js-op">;</span>
<span class="js-id">string</span> <span class="js-id">name</span><span class="js-op">;</span>
<span class="js-id">Department</span> <span class="js-id">department</span><span class="js-op">;</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">Employee</span> <span class="js-id">emp</span> <span class="js-op">=</span> <span class="js-op">{</span>
<span class="js-num">101</span><span class="js-op">,</span>
<span class="js-str">"Amit"</span><span class="js-op">,</span>
<span class="js-id">Department</span><span class="js-op">::</span><span class="js-id">IT</span>
<span class="js-op">};</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Employee ID: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">emp</span><span class="js-op">.</span><span class="js-id">id</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Employee Name: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">emp</span><span class="js-op">.</span><span class="js-id">name</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>

<span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">emp</span><span class="js-op">.</span><span class="js-id">department</span> <span class="js-op">==</span> <span class="js-id">Department</span><span class="js-op">::</span><span class="js-id">IT</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">"Department: IT"</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>Output:</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">Employee</span> <span class="js-id">ID</span><span class="js-op">:</span> <span class="js-num">101</span>
<span class="js-id">Employee</span> <span class="js-id">Name</span><span class="js-op">:</span> <span class="js-id">Amit</span>
<span class="js-id">Department</span><span class="js-op">:</span> <span class="js-id">IT</span></code></pre></div><p>This approach is useful when records need to store values selected from a fixed set of options.</p><h2>13. enum vs const vs constexpr</h2><p>C++ provides several ways to represent constant values. They serve different purposes.</p><table><tbody><tr><th>Feature</th><th>enum</th><th>const</th><th>constexpr</th></tr><tr><td>Main purpose</td><td>Define named related values</td><td>Prevent modification of an object through that name</td><td>Define values usable in constant expressions when initialized appropriately</td></tr><tr><td>Multiple related values</td><td>Yes</td><td>Individual declarations</td><td>Individual declarations or related constants</td></tr><tr><td>User-defined type</td><td>Yes</td><td>No</td><td>No</td></tr><tr><td>Type safety</td><td>Stronger with enum class</td><td>Depends on declared type</td><td>Depends on declared type</td></tr><tr><td>Common use</td><td>Status, category, direction</td><td>Values that must not be modified</td><td>Compile-time constants</td></tr></tbody></table><h3>Example: const</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-kw">const</span> <span class="js-id">int</span> <span class="js-id">maxUsers</span> <span class="js-op">=</span> <span class="js-num">100</span><span class="js-op">;</span></code></pre></div><h3>Example: constexpr</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">constexpr</span> <span class="js-id">int</span> <span class="js-id">maxSize</span> <span class="js-op">=</span> <span class="js-num">50</span><span class="js-op">;</span></code></pre></div><h3>Example: enum class</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">enum</span> <span class="js-kw">class</span> <span class="js-id">Status</span> <span class="js-op">{</span>
<span class="js-id">Pending</span><span class="js-op">,</span>
<span class="js-id">Approved</span><span class="js-op">,</span>
<span class="js-id">Rejected</span>
<span class="js-op">};</span></code></pre></div><p>Use an enumeration when you have a fixed group of named alternatives. Use <code>const</code> or <code>constexpr</code> for individual constant values.</p><h2>14. Real-World Applications of Enumerations in C++</h2><p>Enumerations are useful in many software applications.</p><h3>Order Management Systems</h3><p>Represent order states such as Pending, Processing, Shipped, and Delivered.</p><h3>Banking Applications</h3><p>Represent transaction types such as Deposit, Withdrawal, and Transfer.</p><h3>Game Development</h3><p>Represent game states, player actions, directions, and difficulty levels.</p><h3>Traffic Control Systems</h3><p>Represent traffic light states such as Red, Yellow, and Green.</p><h3>Employee Management Systems</h3><p>Represent departments, employment types, or role categories.</p><h3>Network Applications</h3><p>Represent connection states, request types, and protocol options.</p><h2>15. Common Mistakes When Using enum</h2><h3>Mistake 1: Using an Enumerator Outside Its Scope</h3><p>With <code>enum class</code>, this is incorrect:</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">enum</span> <span class="js-kw">class</span> <span class="js-id">Color</span> <span class="js-op">{</span>
<span class="js-id">Red</span><span class="js-op">,</span>
<span class="js-id">Green</span>
<span class="js-op">};</span>

<span class="js-id">Color</span> <span class="js-id">selected</span> <span class="js-op">=</span> <span class="js-id">Green</span><span class="js-op">;</span> <span class="js-cm">// Compilation error</span></code></pre></div><p>Use the qualified name:</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">Color</span> <span class="js-id">selected</span> <span class="js-op">=</span> <span class="js-id">Color</span><span class="js-op">::</span><span class="js-id">Green</span><span class="js-op">;</span></code></pre></div><h3>Mistake 2: Assigning an Integer Directly to enum class</h3><p>Incorrect:</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">enum</span> <span class="js-kw">class</span> <span class="js-id">Status</span> <span class="js-op">{</span>
<span class="js-id">Pending</span><span class="js-op">,</span>
<span class="js-id">Approved</span>
<span class="js-op">};</span>

<span class="js-id">Status</span> <span class="js-id">current</span> <span class="js-op">=</span> <span class="js-num">1</span><span class="js-op">;</span> <span class="js-cm">// Compilation error</span></code></pre></div><p>Use a named enumerator:</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">Status</span> <span class="js-id">current</span> <span class="js-op">=</span> <span class="js-id">Status</span><span class="js-op">::</span><span class="js-id">Approved</span><span class="js-op">;</span></code></pre></div><p>If you genuinely need a conversion, use an explicit cast after validating the value.</p><h3>Mistake 3: Assuming Enumerator Values Always Start From Zero</h3><p>An unscoped or scoped enumeration can use explicitly assigned values.</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">enum</span> <span class="js-id">Status</span> <span class="js-op">{</span>
<span class="js-id">Pending</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">,</span>
<span class="js-id">Approved</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">,</span>
<span class="js-id">Rejected</span> <span class="js-op">=</span> <span class="js-num">30</span>
<span class="js-op">};</span></code></pre></div><p>Do not assume the first value is always zero.</p><h3>Mistake 4: Reusing Enumerator Names in the Same Scope</h3><p>Traditional unscoped enums introduce their enumerator names into the surrounding scope. Reusing the same name can cause a compilation error.</p><p>Using <code>enum class</code> helps avoid this problem.</p><h3>Mistake 5: Using enum When a Dynamic Set Is Needed</h3><p>An enumeration is appropriate for a fixed set of named alternatives. If values need to be created dynamically at runtime, a different data structure may be more suitable.</p><h2>16. Best Practices for Using Enumerations</h2><ol start="1"><li><p>Prefer <code>enum class</code> for new C++ code.</p></li><li><p>Use meaningful enumerator names.</p></li><li><p>Specify an underlying type when a particular representation is required.</p></li><li><p>Avoid relying on implicit integer conversions.</p></li><li><p>Use <code>switch</code> statements to handle distinct enumeration values.</p></li><li><p>Include a suitable default or handle all expected cases.</p></li><li><p>Use distinct powers of two for bit flags.</p></li><li><p>Avoid using raw numeric values when named enumerators are available.</p></li><li><p>Keep enumeration definitions close to the types and functions that use them.</p></li><li><p>Use enumerations for fixed sets of related values, not arbitrary user-generated data.</p></li></ol><h2>17. Frequently Asked Questions (FAQs)</h2><h3>1. What is an enum in C++?</h3><p>An enum is a user-defined type that defines a set of named constant values.</p><h3>2. Which keyword is used to declare an enumeration?</h3><p>The <code>enum</code> keyword is used to define an enumeration in C++.</p><h3>3. What is the default starting value of an enum?</h3><p>The first enumerator has the value <code>0</code> by default. Each subsequent enumerator normally receives a value one greater than the previous one.</p><h3>4. Can we assign custom values to enum members?</h3><p>Yes. You can assign explicit integral values to enumerators.</p><h3>5. What is enum class in C++?</h3><p><code>enum class</code> is a scoped, strongly typed enumeration introduced in C++11. It prevents enumerator names from being injected into the surrounding scope and does not implicitly convert to integers.</p><h3>6. What is the difference between enum and enum class?</h3><p>Traditional <code>enum</code> values are unscoped and can implicitly convert to integers. <code>enum class</code> values are scoped and require explicit conversion when an integer is needed.</p><h3>7. Can we use enum with switch statements?</h3><p>Yes. Both traditional enums and scoped enums can be used in <code>switch</code> statements.</p><h3>8. Can we compare enum values?</h3><p>Yes. Values of the same enumeration type can be compared using operators such as <code>==</code>, <code>!=</code>, <code>&lt;</code>, and <code>&gt;</code>.</p><h3>9. Can an enum have a custom underlying type?</h3><p>Yes. You can specify an integral type:</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">enum</span> <span class="js-kw">class</span> <span class="js-id">Status</span> <span class="js-op">:</span> <span class="js-id">unsigned</span> <span class="js-id">char</span> <span class="js-op">{</span>
<span class="js-id">Pending</span><span class="js-op">,</span>
<span class="js-id">Approved</span>
<span class="js-op">};</span></code></pre></div><h3>10. Can we use enum inside a structure?</h3><p>Yes. An enumeration can be used as a data member in a structure or class.</p><h3>11. Can enum be used for bit flags?</h3><p>Yes. Enumerations can represent independent bit flags using powers of two and bitwise operations.</p><h3>12. Which is better: enum or enum class?</h3><p>For most modern C++ programs, <code>enum class</code> is preferred because it provides better scope control and stronger type safety.</p>

Code Example

#include <iostream>
#include <cstdint>

// Scoped enum with explicit underlying type uint8_t
enum class NetworkState : uint8_t {
    Disconnected = 0,
    Connecting = 1,
    Connected = 2,
    Error = 255
};

void checkState(NetworkState state) {
    if (state == NetworkState::Connected) {
        std::cout << "Network is healthy and connected.
";
    } else {
        std::cout << "Network state code: " << static_cast<int>(state) << "
";
    }
}

int main() {
    NetworkState current = NetworkState::Connected;
    checkState(current);

    NetworkState err = NetworkState::Error;
    checkState(err);

    std::cout << "Enum storage size: " << sizeof(current) << " byte
";
    return 0;
}

Interview Question & Tips

Q: Why are enum class types preferred over traditional C-style enums in C++?
A: Scoped `enum class` types prevent namespace collisions (e.g. two enums defining `RED`), forbid accidental implicit conversion to integers, and allow explicit specification of underlying storage sizes (e.g. `: uint8_t`).

Q: Can an enum class have an underlying type of int64_t?
A: Yes. Any integral type can be specified: `enum class BigId : int64_t { ... }`.

Best Practices

1. Always use `enum class` instead of unscoped `enum`.
2. Specify small underlying types (e.g. `: uint8_t`) to save memory when enumerators are small.
3. Use `static_cast<UnderlyingType>(e)` when numeric serialization is necessary.
Academic Standards & Verified Citations

This study reference for Enumerations in C++: Defining Named Constant Values With enum is curated and verified against recognized curriculum benchmarks, peer-reviewed textbooks, and official technical documentation:

C++ Programming