C++ Programming 2. C++ Fundamentals 16 mins read 22,805 views

Variables in C++: Declaration, Initialization, Scope, and Storage

Variables are one of the most important concepts in C++. A variable provides a named way to store a value that a program can read, modify, and use during execut...
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 Variables in C++: Declaration, Initialization, Scope, and Storage? Variables are one of the most important concepts in C++. A variable provides a named way to store a value that a program can read, modify, and use during execut...

Audience & Scope: Students, educators, and candidates preparing for academic examinations and technical assessments in C++ Programming.
How do variable declaration, uniform brace initialization, scope, and storage duration operate in C++?
<p data-pm-slice="1 1 []">Variables are one of the most important concepts in C++. A variable provides a named way to store a value that a program can read, modify, and use during execution.</p><p>For example:</p><pre><code class="language-cpp">int age = 35;</code></pre><p>Here, <code dir="ltr">age</code> is a variable of type <code dir="ltr">int</code>, and its initial value is <code dir="ltr">35</code>.</p><p>C++ variables can store many kinds of data, including integers, floating-point numbers, characters, Boolean values, objects, pointers, and user-defined types.</p><p>Understanding <strong>variable declaration, initialization, scope, lifetime, storage duration, and naming rules</strong> is essential before moving to more advanced C++ topics.</p>

Explanation & In-Depth Details

<h2 class="h4 fw-bold text-dark mb-3">What Is a Variable in C++?</h2><p>A variable is a named object that can hold a value.</p><p>For 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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">35</span><span class="js-op">;</span></code></pre></div><p>This statement creates an integer object named <code dir="ltr">age</code>.</p><p>The program can later change its value:</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 class="language-cpp"><span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">36</span><span class="js-op">;</span></code></pre></div><p>After this statement, <code dir="ltr">age</code> contains <code dir="ltr">36</code>.</p><p>A simple way to visualize a variable 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 class="language-text"><span class="js-id">Variable</span> <span class="js-id">name</span>
↓
<span class="js-id">age</span>
│
↓
┌───────────┐
│ <span class="js-num">35</span> │
└───────────┘
↑
<span class="js-id">value</span></code></pre></div><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Why Are Variables Important?</h2><p>Variables allow programs to work with data dynamically.</p><p>For example, a program may store:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">35</span><span class="js-op">;</span>
<span class="js-id">double</span> <span class="js-id">salary</span> <span class="js-op">=</span> <span class="js-num">50000.50</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">'A'</span><span class="js-op">;</span>
<span class="js-id">bool</span> <span class="js-id">isActive</span> <span class="js-op">=</span> <span class="js-num">true</span><span class="js-op">;</span></code></pre></div><p>These values can then be used in calculations, conditions, functions, loops, and objects.</p><p>Without variables, most programs could only work with fixed values written directly into the source code.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Declaring a Variable in C++</h2><p>A variable declaration tells the compiler about the variable's type and name.</p><p>Basic 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 class="language-text"><span class="js-id">type</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">;</span></code></pre></div><p>This declares a variable named <code dir="ltr">age</code> of type <code dir="ltr">int</code>.</p><p>Another 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 class="language-cpp"><span class="js-id">double</span> <span class="js-id">price</span><span class="js-op">;</span></code></pre></div><p>And:</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 class="language-cpp"><span class="js-id">char</span> <span class="js-id">grade</span><span class="js-op">;</span></code></pre></div><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Declaration vs Definition</h2><p>In everyday beginner code, declaration and definition are often discussed together, but technically they are not always the same.</p><p>For 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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">;</span></code></pre></div><p>defines an object named <code dir="ltr">age</code>.</p><p>An external declaration can declare a variable without defining it:</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 class="language-cpp"><span class="js-id">extern</span> <span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">;</span></code></pre></div><p>The actual definition can appear in another source file:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">35</span><span class="js-op">;</span></code></pre></div><p>Understanding this distinction becomes important when working with multiple C++ source files and linkage.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Initializing a Variable</h2><p>Initialization gives a variable its initial value when the object is created.</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">35</span><span class="js-op">;</span></code></pre></div><p>Here:</p><ul data-spread="false"><li><p><code dir="ltr">int</code> is the type.</p></li><li><p><code dir="ltr">age</code> is the variable name.</p></li><li><p><code dir="ltr">35</code> is the initial value.</p></li></ul><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Different Ways to Initialize Variables</h2><p>C++ supports several forms of initialization.</p><h2>Copy Initialization</h2><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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">35</span><span class="js-op">;</span></code></pre></div><p>This is a traditional and familiar syntax.</p><div><hr></div><h2>Direct Initialization</h2><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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">(</span><span class="js-num">35</span><span class="js-op">);</span></code></pre></div><p>The variable is initialized using parentheses.</p><div><hr></div><h2>Brace Initialization</h2><p>Modern C++ commonly uses braces:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span>
<span class="js-num">35</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>Brace initialization is useful because it prevents many narrowing conversions.</p><p>For 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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">number</span><span class="js-op">{</span>
<span class="js-num">3.14</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>is rejected because converting <code dir="ltr">3.14</code> to <code dir="ltr">int</code> would lose information.</p><p>By comparison:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-num">3.14</span><span class="js-op">;</span></code></pre></div><p>allows the conversion, although the fractional part is discarded.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Recommended Initialization Style</h2><p>For modern C++, brace initialization is often a good default:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span><span class="js-num">35</span><span class="js-op">};</span>
<span class="js-id">double</span> <span class="js-id">price</span><span class="js-op">{</span><span class="js-num">99.99</span><span class="js-op">};</span>
<span class="js-id">bool</span> <span class="js-id">active</span><span class="js-op">{</span><span class="js-num">true</span><span class="js-op">};</span></code></pre></div><p>It makes initialization explicit and provides protection against certain narrowing conversions.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Declaring Multiple Variables</h2><p>C++ allows multiple variables of the same type to be declared in one statement:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">x</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">,</span> <span class="js-id">y</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-id">z</span> <span class="js-op">=</span> <span class="js-num">30</span><span class="js-op">;</span></code></pre></div><p>However, separate declarations are often easier to read:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">x</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">y</span><span class="js-op">{</span><span class="js-num">20</span><span class="js-op">};</span>
<span class="js-id">int</span> <span class="js-id">z</span><span class="js-op">{</span><span class="js-num">30</span><span class="js-op">};</span></code></pre></div><p>For larger programs, clarity is generally more important than saving a line.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Variables Without Initialization</h2><p>Consider:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">;</span></code></pre></div><p>What value does <code dir="ltr">age</code> contain?</p><p>The answer depends on where and how the variable is defined.</p><p>For an automatic local variable:</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 class="language-cpp"><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">age</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><code dir="ltr">age</code> is not initialized. Reading its value before assigning one is erroneous.</p><p>Always initialize local variables before using them:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>This value-initializes the integer to <code dir="ltr">0</code>.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Zero Initialization</h2><p>Brace initialization can conveniently initialize a variable to zero:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">count</span><span class="js-op">{};</span>
<span class="js-id">double</span> <span class="js-id">price</span><span class="js-op">{};</span>
<span class="js-id">bool</span> <span class="js-id">active</span><span class="js-op">{};</span></code></pre></div><p>The resulting values are:</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 class="language-text"><span class="js-id">count</span> → <span class="js-num">0</span>
<span class="js-id">price</span> → <span class="js-num">0.0</span>
<span class="js-id">active</span> → <span class="js-num">false</span></code></pre></div><p>This is often safer than leaving local variables uninitialized.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">C++ Variable Data Types</h2><p>Variables can have many different types.</p><h2>Integer</h2><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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span>
<span class="js-num">35</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><h2>Floating Point</h2><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 class="language-cpp"><span class="js-id">double</span> <span class="js-id">price</span><span class="js-op">{</span>
<span class="js-num">99.99</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><h2>Character</h2><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 class="language-cpp"><span class="js-id">char</span> <span class="js-id">grade</span><span class="js-op">{</span>
<span class="js-str">'A'</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><h2>Boolean</h2><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 class="language-cpp"><span class="js-id">bool</span> <span class="js-id">isLoggedIn</span><span class="js-op">{</span>
<span class="js-num">true</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><h2>String</h2><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 class="language-cpp">#<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">std</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-str">"Tanmoy"</span><span class="js-op">};</span></code></pre></div><h2>Pointer</h2><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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">value</span><span class="js-op">{</span><span class="js-num">100</span><span class="js-op">};</span>
<span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span><span class="js-op">{&amp;</span><span class="js-id">value</span><span class="js-op">};</span></code></pre></div><h2>User-Defined Type</h2><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 class="language-cpp"><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-op">};</span>

<span class="js-id">Employee</span> <span class="js-id">employee</span><span class="js-op">{</span><span class="js-num">101</span><span class="js-op">};</span></code></pre></div><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Variable Naming Rules in C++</h2><p>C++ identifiers used for variables must follow the language's identifier rules.</p><p>A variable name:</p><ul data-spread="false"><li><p>Can contain letters.</p></li><li><p>Can contain digits.</p></li><li><p>Can contain underscores.</p></li><li><p>Cannot begin with a digit.</p></li><li><p>Cannot contain spaces.</p></li><li><p>Cannot be a C++ keyword.</p></li><li><p>Is case-sensitive.</p></li></ul><p>Valid examples:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">userAge</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">user_age</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">age2</span><span class="js-op">;</span></code></pre></div><p>Invalid examples:</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 class="language-cpp"><span class="js-id">int</span> 2age<span class="js-op">;</span> <span class="js-cm">// Invalid</span>
<span class="js-id">int</span> <span class="js-id">user</span> <span class="js-id">age</span><span class="js-op">;</span> <span class="js-cm">// Invalid</span>
<span class="js-id">int</span> <span class="js-kw">class</span><span class="js-op">;</span> <span class="js-cm">// Invalid: keyword</span></code></pre></div><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">C++ Variable Names Are Case-Sensitive</h2><p>These are different identifiers:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">Age</span> <span class="js-op">=</span> <span class="js-num">30</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">AGE</span> <span class="js-op">=</span> <span class="js-num">40</span><span class="js-op">;</span></code></pre></div><p>C++ treats them as three separate names.</p><p>However, using names that differ only by capitalization can make code confusing.</p><p>Prefer consistent naming conventions.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Good Variable Naming</h2><p>Use names that explain what the variable represents.</p><p>Instead of:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">x</span> <span class="js-op">=</span> <span class="js-num">35</span><span class="js-op">;</span></code></pre></div><p>prefer:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">35</span><span class="js-op">;</span></code></pre></div><p>Instead of:</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 class="language-cpp"><span class="js-id">double</span> <span class="js-id">p</span> <span class="js-op">=</span> <span class="js-num">99.99</span><span class="js-op">;</span></code></pre></div><p>prefer:</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 class="language-cpp"><span class="js-id">double</span> <span class="js-id">productPrice</span> <span class="js-op">=</span> <span class="js-num">99.99</span><span class="js-op">;</span></code></pre></div><p>Meaningful names make programs easier to read and maintain.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Constants vs Variables</h2><p>A normal variable can be modified:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">35</span><span class="js-op">;</span>
<span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">36</span><span class="js-op">;</span></code></pre></div><p>A constant cannot be modified through its constant declaration:</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 class="language-cpp"><span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-id">maxAge</span> <span class="js-op">=</span> <span class="js-num">100</span><span class="js-op">;</span></code></pre></div><p>Attempting:</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 class="language-cpp"><span class="js-id">maxAge</span> <span class="js-op">=</span> <span class="js-num">101</span><span class="js-op">;</span></code></pre></div><p>produces a compilation error.</p><p>Use a variable when the value needs to change.</p><p>Use <code dir="ltr">const</code> when the value should remain unchanged.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3"><code dir="ltr">constexpr</code> Variables</h2><p>C++ also supports <code dir="ltr">constexpr</code> for values that are required to be constant expressions.</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 class="language-cpp"><span class="js-id">constexpr</span> <span class="js-id">int</span> <span class="js-id">daysInWeek</span> <span class="js-op">=</span> <span class="js-num">7</span><span class="js-op">;</span></code></pre></div><p>A <code dir="ltr">constexpr</code> variable is useful when the value needs to be available during compile-time constant evaluation.</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 class="language-cpp"><span class="js-id">constexpr</span> <span class="js-id">int</span> <span class="js-id">width</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">};</span>
<span class="js-id">constexpr</span> <span class="js-id">int</span> <span class="js-id">height</span><span class="js-op">{</span><span class="js-num">20</span><span class="js-op">};</span>
<span class="js-id">constexpr</span> <span class="js-id">int</span> <span class="js-id">area</span><span class="js-op">{</span><span class="js-id">width</span> <span class="js-op">*</span> <span class="js-id">height</span><span class="js-op">};</span></code></pre></div><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Local Variables</h2><p>A local variable is declared inside a function or block.</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 class="language-cpp">#<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">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">age</span><span class="js-op">{</span><span class="js-num">35</span><span class="js-op">};</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">age</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</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><code dir="ltr">age</code> is local to <code dir="ltr">main()</code>.</p><p>It cannot be directly accessed from outside that scope.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Block Scope</h2><p>Variables declared inside a block exist within that block's scope.</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 class="language-cpp"><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">x</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">};</span>

<span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">y</span><span class="js-op">{</span><span class="js-num">20</span><span class="js-op">};</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">x</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">y</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">x</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>

<span class="js-cm">// std::cout &lt;&lt; y; // Error</span>
<span class="js-op">}</span></code></pre></div><p><code dir="ltr">x</code> is available throughout the outer block.</p><p><code dir="ltr">y</code> exists only inside the inner block.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Nested Scope</h2><p>C++ allows scopes to be nested.</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 class="language-cpp"><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">outer</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">};</span>

<span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">inner</span><span class="js-op">{</span><span class="js-num">20</span><span class="js-op">};</span>

<span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">deeplyNested</span><span class="js-op">{</span><span class="js-num">30</span><span class="js-op">};</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">outer</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">inner</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">deeplyNested</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-op">}</span></code></pre></div><p>An inner scope can generally access names from its surrounding scopes.</p><p>The reverse is not true.</p><p>The outer scope cannot access a variable defined only inside an inner scope.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Variable Shadowing</h2><p>A variable declared in an inner scope can have the same name as a variable in an outer scope.</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">value</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">};</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-num">20</span><span class="js-op">};</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">value</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>The output inside the inner block 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 class="language-text"><span class="js-num">20</span></code></pre></div><p>The inner <code dir="ltr">value</code> hides the outer <code dir="ltr">value</code> within that scope.</p><p>This is called <strong>shadowing</strong>.</p><p>Although legal, excessive shadowing can make code harder to understand.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Global Variables</h2><p>A variable declared at namespace scope can have a lifetime that lasts for the duration of the program.</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">totalUsers</span><span class="js-op">{</span><span class="js-num">100</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">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">totalUsers</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><code dir="ltr">totalUsers</code> is defined at namespace scope.</p><p>Global variables can be accessed by functions according to their linkage and visibility.</p><p>However, global mutable state should be used carefully because many parts of a program can depend on it.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Namespace Scope</h2><p>A variable declared outside functions and classes at namespace scope belongs to a namespace.</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 class="language-cpp"><span class="js-id">namespace</span> <span class="js-id">App</span> <span class="js-op">{</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>
<span class="js-op">}</span></code></pre></div><p>It can be accessed as:</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 class="language-cpp"><span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">App</span><span class="js-op">::</span><span class="js-id">maxUsers</span><span class="js-op">;</span></code></pre></div><p>Namespaces help prevent naming conflicts in larger applications.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Static Local Variables</h2><p>A local variable declared with <code dir="ltr">static</code> has static storage duration.</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 class="language-cpp">#<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-kw">void</span> <span class="js-id">counter</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">static</span> <span class="js-id">int</span> <span class="js-id">count</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">count</span><span class="js-op">;</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">count</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</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">counter</span><span class="js-op">();</span>
<span class="js-id">counter</span><span class="js-op">();</span>
<span class="js-id">counter</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 class="language-text"><span class="js-num">1</span>
<span class="js-num">2</span>
<span class="js-num">3</span></code></pre></div><p>The important point is that <code dir="ltr">count</code> is initialized once and retains its value between function calls.</p><p>Its scope is still local to the function, but its lifetime extends for the entire program.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Scope vs Lifetime</h2><p>These concepts are related but different.</p><h3>Scope</h3><p>Scope describes <strong>where a name can be used in the source code</strong>.</p><h3>Lifetime</h3><p>Lifetime describes <strong>when the object exists during program execution</strong>.</p><p>For 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 class="language-cpp"><span class="js-kw">void</span> <span class="js-id">counter</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">static</span> <span class="js-id">int</span> <span class="js-id">count</span><span class="js-op">{</span><span class="js-num">0</span><span class="js-op">};</span>
<span class="js-op">}</span></code></pre></div><p>The name <code dir="ltr">count</code> has local scope.</p><p>But the object has static storage duration and exists throughout the program's execution.</p><p>So:</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 class="language-text"><span class="js-id">Scope</span> → <span class="js-id">Where</span> <span class="js-id">the</span> <span class="js-id">name</span> <span class="js-id">is</span> <span class="js-id">accessible</span>
<span class="js-id">Lifetime</span> → <span class="js-id">How</span> <span class="js-id">long</span> <span class="js-id">the</span> <span class="js-id">object</span> <span class="js-id">exists</span></code></pre></div><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Storage Duration in C++</h2><p>C++ categorizes objects according to storage duration.</p><p>The main categories are:</p><ul data-spread="false"><li><p>Automatic storage duration</p></li><li><p>Static storage duration</p></li><li><p>Thread storage duration</p></li><li><p>Dynamic storage duration</p></li></ul><p>Understanding storage duration helps explain when variables are created and destroyed.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Automatic Storage Duration</h2><p>Local variables normally have automatic storage duration.</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 class="language-cpp"><span class="js-kw">void</span> <span class="js-id">calculate</span><span class="js-op">()</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-num">100</span><span class="js-op">};</span>
<span class="js-op">}</span></code></pre></div><p><code dir="ltr">value</code> is created when execution reaches its declaration and is destroyed when its scope ends.</p><p>For a local variable:</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 class="language-cpp"><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">x</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">};</span>
<span class="js-op">}</span></code></pre></div><p><code dir="ltr">x</code> normally has automatic storage duration.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Static Storage Duration</h2><p>Variables with static storage duration exist for the duration of the program.</p><p>Examples include:</p><ul data-spread="false"><li><p>Namespace-scope variables with static storage duration.</p></li><li><p>Static local variables.</p></li><li><p>Certain static data members.</p></li></ul><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 class="language-cpp"><span class="js-id">static</span> <span class="js-id">int</span> <span class="js-id">total</span><span class="js-op">{</span>
<span class="js-num">0</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>A static local variable retains its value between function calls.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Thread Storage Duration</h2><p>C++ supports thread-local variables using <code dir="ltr">thread_local</code>.</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 class="language-cpp"><span class="js-id">thread_local</span> <span class="js-id">int</span> <span class="js-id">requestCount</span><span class="js-op">{</span>
<span class="js-num">0</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>Each thread gets its own instance of the variable.</p><p>This is useful in multithreaded programs when each thread needs independent storage.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Dynamic Storage Duration</h2><p>Objects created dynamically have dynamic storage duration.</p><p>For 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 class="language-cpp"><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-kw">new</span> <span class="js-id">int</span><span class="js-op">{</span>
<span class="js-num">100</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>The dynamically allocated integer exists until it is released.</p><p>Modern C++ should generally avoid raw <code dir="ltr">new</code> and <code dir="ltr">delete</code> when ownership can instead be managed by RAII and smart pointers.</p><p>For 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 class="language-cpp">#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">memory</span><span class="js-op">&gt;</span>

<span class="js-id">auto</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-id">std</span><span class="js-op">::</span><span class="js-id">make_unique</span><span class="js-op">&lt;</span><span class="js-id">int</span><span class="js-op">&gt;(</span><span class="js-num">100</span><span class="js-op">);</span></code></pre></div><p>The <code dir="ltr">unique_ptr</code> automatically releases the object when it goes out of scope.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Variable Lifetime Example</h2><p>Consider:</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 class="language-cpp"><span class="js-kw">void</span> <span class="js-id">test</span><span class="js-op">()</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-num">100</span><span class="js-op">};</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">value</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>When execution enters the function and reaches:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">value</span><span class="js-op">{</span>
<span class="js-num">100</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>the variable is created.</p><p>When the function exits, the local variable is destroyed.</p><p>Conceptually:</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 class="language-text"><span class="js-id">Function</span> <span class="js-id">starts</span>
↓
<span class="js-id">Variable</span> <span class="js-id">created</span>
↓
<span class="js-id">Variable</span> <span class="js-id">used</span>
↓
<span class="js-id">Function</span> <span class="js-id">ends</span>
↓
<span class="js-id">Variable</span> <span class="js-id">destroyed</span></code></pre></div><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Storage Duration vs Scope</h2><p>These terms should not be confused.</p><table><tbody><tr><th>Concept</th><th>Meaning</th></tr><tr><td>Scope</td><td>Where a variable name can be referenced</td></tr><tr><td>Lifetime</td><td>Period during which an object exists</td></tr><tr><td>Storage duration</td><td>C++ classification describing how long storage for an object lasts</td></tr><tr><td>Linkage</td><td>Whether a name can refer to an entity across scopes/translation units</td></tr></tbody></table><p>For beginners, the most important distinction 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 class="language-text"><span class="js-id">Scope</span> <span class="js-op">=</span> <span class="js-id">where</span>
<span class="js-id">Lifetime</span> <span class="js-op">=</span> <span class="js-id">when</span></code></pre></div><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Initialization and Assignment Are Different</h2><p>These two operations are not the same.</p><p>Initialization:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span>
<span class="js-num">35</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>The object is created and initialized.</p><p>Assignment:</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 class="language-cpp"><span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">36</span><span class="js-op">;</span></code></pre></div><p>The existing object's value is changed.</p><p>Another 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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">x</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">};</span> <span class="js-cm">// Initialization</span>
<span class="js-id">x</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span> <span class="js-cm">// Assignment</span></code></pre></div><p>Understanding this distinction becomes particularly important with <code dir="ltr">const</code> objects and classes.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Multiple Assignment Operations</h2><p>A variable can be assigned repeatedly:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">score</span><span class="js-op">{</span><span class="js-num">0</span><span class="js-op">};</span>

<span class="js-id">score</span> <span class="js-op">=</span> <span class="js-num">10</span><span class="js-op">;</span>
<span class="js-id">score</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span>
<span class="js-id">score</span> <span class="js-op">=</span> <span class="js-num">30</span><span class="js-op">;</span></code></pre></div><p>After the final assignment:</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 class="language-text"><span class="js-id">score</span> <span class="js-op">=</span> <span class="js-num">30</span></code></pre></div><p>This is different from initialization because the object already exists.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Reading User Input Into Variables</h2><p>Variables become especially useful when combined with input.</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 class="language-cpp">#<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">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">age</span><span class="js-op">{};</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Enter your age: "</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cin</span> <span class="js-op">&gt;&gt;</span> <span class="js-id">age</span><span class="js-op">;</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Your age is: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">age</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</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>The variable <code dir="ltr">age</code> first receives the value <code dir="ltr">0</code> through initialization and then receives user input through assignment performed by <code dir="ltr">std::cin</code>.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Example: Variables in a Simple Program</h2><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 class="language-cpp">#<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">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">std</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">int</span> <span class="js-id">age</span><span class="js-op">{};</span>
<span class="js-id">double</span> <span class="js-id">salary</span><span class="js-op">{};</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Enter your name: "</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cin</span> <span class="js-op">&gt;&gt;</span> <span class="js-id">name</span><span class="js-op">;</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Enter your age: "</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cin</span> <span class="js-op">&gt;&gt;</span> <span class="js-id">age</span><span class="js-op">;</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Enter your salary: "</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cin</span> <span class="js-op">&gt;&gt;</span> <span class="js-id">salary</span><span class="js-op">;</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"\nEmployee Information\n"</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Name: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">name</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Age: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">age</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Salary: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">salary</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</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>This example demonstrates several variables with different types.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Variables and Memory</h2><p>A variable represents an object that occupies storage according to its type and storage duration.</p><p>For 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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span>
<span class="js-num">35</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>The program has an object named <code dir="ltr">age</code> containing an integer value.</p><p>You can obtain its address using the address-of operator:</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 class="language-cpp"><span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">&amp;</span><span class="js-id">age</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 class="language-cpp">#<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">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">age</span><span class="js-op">{</span><span class="js-num">35</span><span class="js-op">};</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Value: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">age</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Address: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">&amp;</span><span class="js-id">age</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</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>The exact memory address can change between executions.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Variable and Pointer Relationship</h2><p>A pointer can store the address of a variable.</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span><span class="js-num">35</span><span class="js-op">};</span>

<span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span><span class="js-op">{&amp;</span><span class="js-id">age</span><span class="js-op">};</span></code></pre></div><p>Here:</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 class="language-text"><span class="js-id">age</span>
↓
<span class="js-num">35</span>

<span class="js-id">ptr</span>
↓
<span class="js-id">address</span> <span class="js-kw">of</span> <span class="js-id">age</span></code></pre></div><p>You can access the value through the pointer:</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 class="language-cpp"><span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">*</span><span class="js-id">ptr</span><span class="js-op">;</span></code></pre></div><p>This prints:</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 class="language-text"><span class="js-num">35</span></code></pre></div><p>Pointers are covered in more detail in a dedicated C++ pointers topic.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Reference Variables</h2><p>A reference provides another name for an existing object.</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span><span class="js-num">35</span><span class="js-op">};</span>
<span class="js-id">int</span><span class="js-op">&amp;</span> <span class="js-id">reference</span><span class="js-op">{</span><span class="js-id">age</span><span class="js-op">};</span></code></pre></div><p>Now:</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 class="language-cpp"><span class="js-id">reference</span> <span class="js-op">=</span> <span class="js-num">36</span><span class="js-op">;</span></code></pre></div><p>also changes <code dir="ltr">age</code>.</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 class="language-cpp"><span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">age</span><span class="js-op">;</span></code></pre></div><p>prints:</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 class="language-text"><span class="js-num">36</span></code></pre></div><p>References are heavily used in C++ function parameters and object-oriented programming.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3"><code dir="ltr">auto</code> Variables</h2><p>Modern C++ allows the compiler to deduce a variable's type using <code dir="ltr">auto</code>.</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 class="language-cpp"><span class="js-id">auto</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">35</span><span class="js-op">;</span></code></pre></div><p>The compiler deduces:</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 class="language-text"><span class="js-id">int</span></code></pre></div><p>Another 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 class="language-cpp"><span class="js-id">auto</span> <span class="js-id">price</span> <span class="js-op">=</span> <span class="js-num">99.99</span><span class="js-op">;</span></code></pre></div><p>The type is deduced as:</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 class="language-text"><span class="js-id">double</span></code></pre></div><p><code dir="ltr">auto</code> does not mean the variable has no type. The variable still has a specific compile-time type.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3"><code dir="ltr">auto</code> With Initialization</h2><p>Because <code dir="ltr">auto</code> requires type deduction from an initializer, this is valid:</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 class="language-cpp"><span class="js-id">auto</span> <span class="js-id">number</span><span class="js-op">{</span>
<span class="js-num">100</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>The deduced type is <code dir="ltr">int</code>.</p><p>But:</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 class="language-cpp"><span class="js-id">auto</span> <span class="js-id">number</span><span class="js-op">;</span></code></pre></div><p>is invalid because there is no initializer from which to deduce the type.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3"><code dir="ltr">const auto</code></h2><p>You can combine <code dir="ltr">const</code> with <code dir="ltr">auto</code>:</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 class="language-cpp"><span class="js-kw">const</span> <span class="js-id">auto</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><p>The compiler deduces the type and the variable cannot be modified.</p><p>You can also use:</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 class="language-cpp"><span class="js-id">constexpr</span> <span class="js-id">auto</span> <span class="js-id">daysInWeek</span> <span class="js-op">=</span> <span class="js-num">7</span><span class="js-op">;</span></code></pre></div><p>when the value is a suitable constant expression.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Variable Scope Example</h2><p>Consider:</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 class="language-cpp">#<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">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">outer</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">};</span>

<span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">outer</span> <span class="js-op">&gt;</span> <span class="js-num">5</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">inner</span><span class="js-op">{</span><span class="js-num">20</span><span class="js-op">};</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">outer</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">inner</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">outer</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>

<span class="js-cm">// std::cout &lt;&lt; inner; // Error</span>
<span class="js-op">}</span></code></pre></div><p>The <code dir="ltr">outer</code> variable is available inside the <code dir="ltr">if</code> block because the block is nested inside the scope where <code dir="ltr">outer</code> was declared.</p><p>The <code dir="ltr">inner</code> variable cannot be used after the <code dir="ltr">if</code> block ends.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Scope in Loops</h2><p>Variables declared inside a loop generally have scope limited to that loop statement's relevant block.</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 class="language-cpp"><span class="js-kw">for</span> <span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">i</span><span class="js-op">{</span><span class="js-num">0</span><span class="js-op">};</span> <span class="js-id">i</span> <span class="js-op">&lt;</span> <span class="js-num">5</span><span class="js-op">;</span> <span class="js-op">++</span><span class="js-id">i</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">i</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>The variable <code dir="ltr">i</code> is not available after the loop:</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 class="language-cpp"><span class="js-cm">// std::cout &lt;&lt; i; // Error</span></code></pre></div><p>This is useful because temporary loop variables do not remain visible unnecessarily.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Scope in Functions</h2><p>Function parameters also have scope within the function body.</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 class="language-cpp"><span class="js-kw">void</span> <span class="js-id">greet</span><span class="js-op">(</span><span class="js-id">std</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-op">{</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">name</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>The parameter <code dir="ltr">name</code> can be used within the function body.</p><p>It is not directly accessible from the caller.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Variable Shadowing in Functions</h2><p>Consider:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">value</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">};</span>

<span class="js-kw">void</span> <span class="js-id">test</span><span class="js-op">()</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-num">20</span><span class="js-op">};</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">value</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>The local <code dir="ltr">value</code> hides the outer <code dir="ltr">value</code> inside <code dir="ltr">test()</code>.</p><p>The output 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 class="language-text"><span class="js-num">20</span></code></pre></div><p>Avoid unnecessary shadowing because it can make debugging more difficult.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Storage and Performance</h2><p>Variable storage choices can affect performance and memory usage, but beginners should avoid optimizing based solely on assumptions about where a variable "lives."</p><p>For example, local variables often have automatic storage duration, but the compiler may keep values in registers or optimize them away entirely.</p><p>Likewise, saying that every local variable is physically stored on the stack is an oversimplification.</p><p>The C++ language specifies object lifetime and storage duration rules; the compiler and platform determine many implementation details.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Common Mistakes With C++ Variables</h2><h2>1. Using an Uninitialized Local Variable</h2><p>Avoid:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">score</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">score</span><span class="js-op">;</span></code></pre></div><p>Instead:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">score</span><span class="js-op">{};</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">score</span><span class="js-op">;</span></code></pre></div><div><hr></div><h2>2. Using the Wrong Type</h2><p>Avoid storing values in a type that cannot represent the required range or precision.</p><p>For 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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">price</span> <span class="js-op">=</span> <span class="js-num">99.99</span><span class="js-op">;</span></code></pre></div><p>loses the fractional part.</p><p>Use:</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 class="language-cpp"><span class="js-id">double</span> <span class="js-id">price</span><span class="js-op">{</span>
<span class="js-num">99.99</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>when a floating-point value is appropriate.</p><div><hr></div><h2>3. Using Meaningless Names</h2><p>Avoid:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">x</span><span class="js-op">{</span>
<span class="js-num">35</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>when the value represents age.</p><p>Prefer:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span>
<span class="js-num">35</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><div><hr></div><h2>4. Accidentally Shadowing Variables</h2><p>Avoid unnecessarily reusing the same 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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">count</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">};</span>

<span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">count</span><span class="js-op">{</span><span class="js-num">20</span><span class="js-op">};</span>
<span class="js-op">}</span></code></pre></div><p>Although legal, it can make code harder to follow.</p><div><hr></div><h2>5. Creating Global Mutable State Without a Good Reason</h2><p>Global variables can create hidden dependencies between different parts of a program.</p><p>Prefer local variables or controlled interfaces where possible.</p><div><hr></div><h2>6. Confusing Assignment With Initialization</h2><p>Remember:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">x</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">};</span> <span class="js-cm">// Initialization</span>
<span class="js-id">x</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span> <span class="js-cm">// Assignment</span></code></pre></div><div><hr></div><h2>7. Assuming Variable Size</h2><p>Do not assume that every C++ type has the same size on every platform.</p><p>Use:</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 class="language-cpp"><span class="js-id">sizeof</span><span class="js-op">(</span><span class="js-id">type</span><span class="js-op">)</span></code></pre></div><p>or fixed-width types from <code dir="ltr">&lt;cstdint&gt;</code> when exact width matters.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Best Practices for C++ Variables</h2><h3>Initialize variables</h3><p>Prefer:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">count</span><span class="js-op">{</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>instead of leaving a local variable uninitialized.</p><h3>Use meaningful names</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 class="language-cpp"><span class="js-id">double</span> <span class="js-id">accountBalance</span><span class="js-op">{</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>is clearer than:</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 class="language-cpp"><span class="js-id">double</span> <span class="js-id">x</span><span class="js-op">{</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><h3>Prefer <code dir="ltr">const</code> when a value should not change</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 class="language-cpp"><span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-id">maxRetries</span><span class="js-op">{</span>
<span class="js-num">3</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><h3>Use <code dir="ltr">constexpr</code> for compile-time constants</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 class="language-cpp"><span class="js-id">constexpr</span> <span class="js-id">int</span> <span class="js-id">daysInWeek</span><span class="js-op">{</span>
<span class="js-num">7</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><h3>Keep scope as small as practical</h3><p>Declare a variable close to where it is needed.</p><h3>Avoid unnecessary global mutable variables</h3><p>Local state is usually easier to reason about.</p><h3>Use <code dir="ltr">auto</code> when it improves readability</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 class="language-cpp"><span class="js-id">auto</span> <span class="js-id">total</span> <span class="js-op">=</span> <span class="js-id">price</span> <span class="js-op">*</span> <span class="js-id">quantity</span><span class="js-op">;</span></code></pre></div><p>But do not use <code dir="ltr">auto</code> when it makes the type difficult to understand.</p><h3>Prefer RAII for resource-owning objects</h3><p>Modern C++ classes and smart pointers can automatically manage resources according to object lifetime.</p><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">C++ Variable Cheat Sheet</h2><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 class="language-cpp">#<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">int</span> <span class="js-id">globalValue</span><span class="js-op">{</span><span class="js-num">100</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-cm">// Basic variable</span>
<span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span><span class="js-num">35</span><span class="js-op">};</span>

<span class="js-cm">// Floating-point variable</span>
<span class="js-id">double</span> <span class="js-id">salary</span><span class="js-op">{</span><span class="js-num">50000.50</span><span class="js-op">};</span>

<span class="js-cm">// Character</span>
<span class="js-id">char</span> <span class="js-id">grade</span><span class="js-op">{</span><span class="js-str">'A'</span><span class="js-op">};</span>

<span class="js-cm">// Boolean</span>
<span class="js-id">bool</span> <span class="js-id">active</span><span class="js-op">{</span><span class="js-num">true</span><span class="js-op">};</span>

<span class="js-cm">// String</span>
<span class="js-id">std</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-str">"Tanmoy"</span><span class="js-op">};</span>

<span class="js-cm">// Constant</span>
<span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-id">maxAge</span><span class="js-op">{</span><span class="js-num">100</span><span class="js-op">};</span>

<span class="js-cm">// Compile-time constant</span>
<span class="js-id">constexpr</span> <span class="js-id">int</span> <span class="js-id">daysInWeek</span><span class="js-op">{</span><span class="js-num">7</span><span class="js-op">};</span>

<span class="js-cm">// Type deduction</span>
<span class="js-id">auto</span> <span class="js-id">score</span><span class="js-op">{</span><span class="js-num">95</span><span class="js-op">};</span>

<span class="js-cm">// Pointer</span>
<span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span><span class="js-op">{&amp;</span><span class="js-id">age</span><span class="js-op">};</span>

<span class="js-cm">// Reference</span>
<span class="js-id">int</span><span class="js-op">&amp;</span> <span class="js-id">ref</span><span class="js-op">{</span><span class="js-id">age</span><span class="js-op">};</span>

<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">name</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">age</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">salary</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">grade</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">active</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">maxAge</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">daysInWeek</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">score</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-op">*</span><span class="js-id">ptr</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</span><span class="js-op">;</span>
<span class="js-id">std</span><span class="js-op">::</span><span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">ref</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">'\n'</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><div><hr></div><h2 class="h4 fw-bold text-dark mb-3">Frequently Asked Questions</h2><h2>What is a variable in C++?</h2><p>A variable is a named object that stores a value and can usually be modified during program execution.</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span>
<span class="js-num">35</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>Here, <code dir="ltr">age</code> is a variable.</p><h2>How do you declare a variable in C++?</h2><p>Use 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 class="language-cpp"><span class="js-id">type</span> <span class="js-id">variableName</span><span class="js-op">;</span></code></pre></div><p>For 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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">;</span></code></pre></div><h2>How do you initialize a variable in C++?</h2><p>You can initialize a variable using several forms:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">35</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">(</span><span class="js-num">35</span><span class="js-op">);</span>
<span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span><span class="js-num">35</span><span class="js-op">};</span></code></pre></div><p>Brace initialization is often preferred in modern C++.</p><h2>What is the difference between declaration and initialization?</h2><p>Declaration introduces a name and type. Initialization gives an object its initial value when it is created.</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span>
<span class="js-num">35</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><p>creates and initializes the variable.</p><h2>What happens if a local variable is not initialized?</h2><p>An automatic local variable of a fundamental type is not automatically initialized to zero. Reading its value before assigning a valid value is erroneous.</p><p>Prefer:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">count</span><span class="js-op">{</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><h2>What is variable scope in C++?</h2><p>Scope determines where a variable's name can be used in the source code.</p><p>A variable declared inside a block is generally accessible only within that block and its nested scopes.</p><h2>What is the lifetime of a variable?</h2><p>Lifetime is the period during which the object exists during program execution.</p><p>Scope and lifetime are different concepts.</p><h2>What is a global variable?</h2><p>A variable defined at namespace scope can have a lifetime spanning the entire program. Such variables should be used carefully when they represent mutable shared state.</p><h2>What is a static variable in C++?</h2><p>A variable with <code dir="ltr">static</code> can have static storage duration. A static local variable retains its value between function calls.</p><h2>What is <code dir="ltr">auto</code> in C++?</h2><p><code dir="ltr">auto</code> allows the compiler to deduce a variable's type from its initializer.</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 class="language-cpp"><span class="js-id">auto</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">35</span><span class="js-op">;</span></code></pre></div><p>The type is deduced as <code dir="ltr">int</code>.</p><h2>What is the difference between a variable and a constant?</h2><p>A normal variable can be modified:</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span><span class="js-num">35</span><span class="js-op">};</span>
<span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">36</span><span class="js-op">;</span></code></pre></div><p>A constant cannot be modified through its constant declaration:</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 class="language-cpp"><span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-id">maxAge</span><span class="js-op">{</span>
<span class="js-num">100</span>
<span class="js-op">}</span>
<span class="js-op">;</span></code></pre></div><h2>What is variable shadowing?</h2><p>Shadowing occurs when a variable declared in an inner scope uses the same name as a variable from an outer scope.</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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">value</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">};</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-num">20</span><span class="js-op">};</span>
<span class="js-op">}</span></code></pre></div><p>The inner variable hides the outer one within the inner scope.</p><p><br></p><h2 data-pm-slice="1 1 []">Suggested Graphic Design</h2><p>Create an educational infographic titled:</p><p><strong>“C++ Variables: From Declaration to Lifetime”</strong></p><p>Show the following flow:</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 class="language-text"> <span class="js-id">C</span><span class="js-op">++</span> <span class="js-id">VARIABLE</span>
│
┌───────────┴───────────┐
│ │
<span class="js-id">DECLARATION</span> <span class="js-id">INITIALIZATION</span>
│ │
<span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">;</span> <span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span><span class="js-num">35</span><span class="js-op">};</span>
│ │
└───────────┬───────────┘
↓
<span class="js-id">VARIABLE</span>
│
┌───────────┼───────────┐
↓

↓

↓
<span class="js-id">SCOPE</span> <span class="js-id">LIFETIME</span> <span class="js-id">STORAGE</span>
│ │ │
<span class="js-id">Local</span> <span class="js-id">Temporary</span> <span class="js-id">Automatic</span>
<span class="js-id">Block</span> <span class="js-id">Static</span> <span class="js-id">Static</span>
<span class="js-id">Global</span> <span class="js-id">Dynamic</span> <span class="js-id">Thread</span>
<span class="js-id">Dynamic</span></code></pre></div><p>Add a small code 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 class="language-cpp"><span class="js-id">int</span> <span class="js-id">age</span><span class="js-op">{</span><span class="js-num">35</span><span class="js-op">};</span>

<span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">score</span><span class="js-op">{</span><span class="js-num">95</span><span class="js-op">};</span>
<span class="js-op">}</span></code></pre></div><p>Then visually show:</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 class="language-text"><span class="js-id">Outer</span> <span class="js-id">Scope</span>
┌──────────────────────────────┐
│ <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">35</span> │
│ │
│ <span class="js-id">Inner</span> <span class="js-id">Scope</span> │
│ ┌──────────────────────┐ │
│ │ <span class="js-id">score</span> <span class="js-op">=</span> <span class="js-num">95</span> │ │
│ └──────────────────────┘ │
│ │
└──────────────────────────────┘</code></pre></div><p>Add a bottom comparison:</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 class="language-text"><span class="js-id">Scope</span> → <span class="js-id">Where</span> <span class="js-id">the</span> <span class="js-id">name</span> <span class="js-id">can</span> <span class="js-id">be</span> <span class="js-id">used</span>
<span class="js-id">Lifetime</span> → <span class="js-id">When</span> <span class="js-id">the</span> <span class="js-id">object</span> <span class="js-id">exists</span>
<span class="js-id">Storage</span> <span class="js-id">Duration</span> → <span class="js-id">How</span> <span class="js-id">long</span> <span class="js-id">its</span> <span class="js-id">storage</span> <span class="js-id">lasts</span></code></pre></div>

Code Example

#include <iostream>

int globalConfig = 100; // Static storage duration

void countInvocations() {
    static int callCount = 0; // Preserves state across calls
    callCount++;
    std::cout << "Function called " << callCount << " times
";
}

int main() {
    // Uniform initialization
    int stackVal{42};

    {
        int blockScopeVar{99};
        std::cout << "Inside block: " << blockScopeVar << "
";
    } // blockScopeVar destroyed here

    countInvocations();
    countInvocations();
    countInvocations();

    std::cout << "Main stack variable: " << stackVal << "
";
    return 0;
}

Interview Question & Tips

Q: What is narrowing conversion and how does uniform initialization prevent it?
A: Narrowing occurs when converting a value to a type that cannot represent all possible values (e.g. `double` to `int`). `int x = 3.14;` silently truncates to `3`, whereas `int x{3.14};` fails to compile, catching precision loss bugs early.

Q: What is the behavior of a static local variable in a function?
A: A static local variable is initialized exactly once the first time control passes through its declaration and persists in memory throughout the entire execution of the program.

Best Practices

1. Always use uniform brace initialization `Type name{val};` to prevent narrowing bugs.
2. Declare variables in the narrowest possible scope immediately before use.
3. Minimize global mutable variables; prefer namespace-scoped constants or dependency injection.
Academic Standards & Verified Citations

This study reference for Variables in C++: Declaration, Initialization, Scope, and Storage is curated and verified against recognized curriculum benchmarks, peer-reviewed textbooks, and official technical documentation:

C++ Programming