Pointers in C++: Memory Addresses, Dereferencing, and Practical Uses
What is Pointers in C++: Memory Addresses, Dereferencing, and Practical Uses? Pointers are one of the most important concepts in C++. They allow a program to work directly with memory addresses and access data stored at those locations.Po...
How do pointers store memory addresses, perform dereferencing, and manipulate memory directly in C++?
Explanation & In-Depth Details
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-num">25</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">=</span> <span class="js-op">&</span><span class="js-id">number</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Value: "</span> <span class="js-op"><<</span> <span class="js-id">number</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Address: "</span> <span class="js-op"><<</span> <span class="js-op">&</span><span class="js-id">number</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Pointer value: "</span> <span class="js-op"><<</span> <span class="js-id">ptr</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Value through pointer: "</span> <span class="js-op"><<</span> <span class="js-op">*</span><span class="js-id">ptr</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Example output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Value</span><span class="js-op">:</span> <span class="js-num">25</span>
<span class="js-id">Address</span><span class="js-op">:</span> 0x7ffe1234
<span class="js-id">Pointer</span> <span class="js-id">value</span><span class="js-op">:</span> 0x7ffe1234
<span class="js-id">Value</span> <span class="js-id">through</span> <span class="js-id">pointer</span><span class="js-op">:</span> <span class="js-num">25</span></code></pre></div><p>The memory address shown above is illustrative. Actual addresses differ between program executions and systems.</p><h3>Explanation</h3><ul><li><p><code>number</code> stores the integer value <code>25</code>.</p></li><li><p><code>&number</code> obtains the memory address of <code>number</code>.</p></li><li><p><code>ptr</code> stores that address.</p></li><li><p><code>*ptr</code> accesses the value stored at that address.</p></li></ul><p>A pointer provides indirect access to another variable.</p><h2>2. Pointer Declaration in C++</h2><p>To declare a pointer, specify the data type followed by an asterisk (<code>*</code>) and the pointer variable name.</p><h3>Syntax</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">data_type</span><span class="js-op">*</span> <span class="js-id">pointer_name</span><span class="js-op">;</span></code></pre></div><h3>Examples</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">intPtr</span><span class="js-op">;</span>
<span class="js-id">float</span><span class="js-op">*</span> <span class="js-id">floatPtr</span><span class="js-op">;</span>
<span class="js-id">double</span><span class="js-op">*</span> <span class="js-id">doublePtr</span><span class="js-op">;</span>
<span class="js-id">char</span><span class="js-op">*</span> <span class="js-id">charPtr</span><span class="js-op">;</span></code></pre></div><p>Each pointer has a type that determines the type of object it can point to.</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><span class="js-id">int</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-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&</span><span class="js-id">number</span><span class="js-op">;</span></code></pre></div><p>Here, <code>ptr</code> is an integer pointer because it points to an integer variable.</p><h3>Different pointer declaration styles</h3><p>All the following declarations are 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><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr1</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-op">*</span><span class="js-id">ptr2</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-op">*</span> <span class="js-id">ptr3</span><span class="js-op">;</span></code></pre></div><p>They have the same meaning. A common style is <code>int* ptr</code>.</p><p><strong>Important:</strong> When declaring multiple pointers, remember that the asterisk belongs to each declarator.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">first</span><span class="js-op">,</span> <span class="js-id">second</span><span class="js-op">;</span></code></pre></div><p>Here, <code>first</code> is a pointer, but <code>second</code> is a normal integer.</p><p>To declare two pointers:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-op">*</span><span class="js-id">first</span><span class="js-op">,</span> <span class="js-op">*</span><span class="js-id">second</span><span class="js-op">;</span></code></pre></div><h2>3. Understanding the Address-of Operator (&)</h2><p>The address-of operator (<code>&</code>) returns the memory address of a variable.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">age</span> <span class="js-op">=</span> <span class="js-num">30</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Age: "</span> <span class="js-op"><<</span> <span class="js-id">age</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Memory address: "</span> <span class="js-op"><<</span> <span class="js-op">&</span><span class="js-id">age</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Example output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Age</span><span class="js-op">:</span> <span class="js-num">30</span>
<span class="js-id">Memory</span> <span class="js-id">address</span><span class="js-op">:</span> 0x7ffe1234</code></pre></div><p>The address is not fixed. It can change when the program runs again.</p><h3>Using the address operator with a pointer</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">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-op">*</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&</span><span class="js-id">age</span><span class="js-op">;</span></code></pre></div><p>The expression <code>&age</code> gets the address of <code>age</code>, and that address is stored in <code>ptr</code>.</p><h2>4. Understanding the Dereference Operator (*)</h2><p>The dereference operator (<code>*</code>) accesses the value stored at the memory address held by a pointer.</p><p>This operation is also called indirection.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-num">50</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">=</span> <span class="js-op">&</span><span class="js-id">number</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-op">*</span><span class="js-id">ptr</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">50</span></code></pre></div><h3>Changing a variable through a pointer</h3><p>You can also modify the original variable by dereferencing its 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>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-num">50</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">=</span> <span class="js-op">&</span><span class="js-id">number</span><span class="js-op">;</span>
<span class="js-op">*</span><span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-num">100</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Number: "</span> <span class="js-op"><<</span> <span class="js-id">number</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Number</span><span class="js-op">:</span> <span class="js-num">100</span></code></pre></div><p>The statement <code>*ptr = 100</code> changes the value of the variable whose address is stored in <code>ptr</code>.</p><h3>Difference between & and *</h3><table><tbody><tr><th>Operator</th><th>Meaning</th><th>Example</th></tr><tr><td><code>&</code></td><td>Gets a variable's address</td><td><code>&number</code></td></tr><tr><td><code>*</code></td><td>Declares a pointer or dereferences one</td><td><code>int* ptr</code>, <code>*ptr</code></td></tr></tbody></table><h2>5. How to Initialize a Pointer</h2><p>A pointer should be initialized before it is dereferenced.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">value</span> <span class="js-op">=</span> <span class="js-num">75</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">=</span> <span class="js-op">&</span><span class="js-id">value</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-op">*</span><span class="js-id">ptr</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">75</span></code></pre></div><h3>Uninitialized pointer</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span><span class="js-op">;</span>
<span class="js-cm">// Do not dereference ptr here.</span></code></pre></div><p>An uninitialized pointer contains an indeterminate value. Dereferencing it can cause undefined behavior.</p><p>A safer option is to initialize a pointer to <code>nullptr</code> when it does not yet point to an object.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-id">nullptr</span><span class="js-op">;</span></code></pre></div><h2>6. Null Pointers in C++</h2><p>A null pointer does not point to a valid object or function.</p><p>C++ provides the <code>nullptr</code> keyword to represent a null pointer.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-id">nullptr</span><span class="js-op">;</span>
<span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">ptr</span> <span class="js-op">==</span> <span class="js-id">nullptr</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Pointer is null"</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Pointer</span> <span class="js-id">is</span> <span class="js-num">null</span></code></pre></div><h3>Why use nullptr?</h3><ul><li><p>It makes the pointer's empty state clear.</p></li><li><p>It helps prevent accidental use of uninitialized pointer values.</p></li><li><p>It can be checked before accessing an object.</p></li><li><p>It is safer and clearer than using the integer literal <code>0</code>.</p></li></ul><p><strong>Important:</strong> Never dereference a null pointer.</p><h2>7. Pointer Arithmetic in C++</h2><p>Pointer arithmetic allows certain operations on pointers, such as moving to the next or previous element of an array.</p><p>When a pointer is incremented, it advances by the size of the type it points to, not necessarily by one byte.</p><h3>Example: Incrementing a pointer</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">numbers</span>[] <span class="js-op">=</span> <span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">,</span> <span class="js-num">40</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">=</span> <span class="js-id">numbers</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-op">*</span><span class="js-id">ptr</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">ptr</span><span class="js-op">++;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-op">*</span><span class="js-id">ptr</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span>
<span class="js-num">20</span></code></pre></div><p>The pointer initially points to the first array element. After <code>ptr++</code>, it points to the next element.</p><h3>Common pointer arithmetic operations</h3><table><tbody><tr><th>Operation</th><th>Meaning</th></tr><tr><td><code>ptr++</code></td><td>Moves to the next element</td></tr><tr><td><code>ptr--</code></td><td>Moves to the previous element</td></tr><tr><td><code>ptr + n</code></td><td>Moves forward by <code>n</code> elements</td></tr><tr><td><code>ptr - n</code></td><td>Moves backward by <code>n</code> elements</td></tr><tr><td><code>ptr1 - ptr2</code></td><td>Calculates the element distance between pointers into the same array</td></tr></tbody></table><p>Pointer arithmetic is only valid within the same array object or one position past its last element. The one-past position must not be dereferenced.</p><h2>8. Pointers and Arrays</h2><p>Pointers and arrays are closely related in C++.</p><p>In many expressions, an array name converts to a pointer to its first element. This is called array-to-pointer conversion.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">numbers</span>[] <span class="js-op">=</span> <span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">,</span> <span class="js-num">40</span><span class="js-op">,</span> <span class="js-num">50</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">=</span> <span class="js-id">numbers</span><span class="js-op">;</span>
<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"><</span> <span class="js-num">5</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">cout</span> <span class="js-op"><<</span> <span class="js-op">*(</span><span class="js-id">ptr</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">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span>
<span class="js-num">20</span>
<span class="js-num">30</span>
<span class="js-num">40</span>
<span class="js-num">50</span></code></pre></div><h3>Explanation</h3><ul><li><p><code>numbers</code> converts to a pointer to its first element in this assignment.</p></li><li><p><code>ptr</code> points to <code>numbers[0]</code>.</p></li><li><p><code>ptr + i</code> points to the element at index <code>i</code>.</p></li><li><p><code>*(ptr + i)</code> reads that element.</p></li></ul><p>For an array, these expressions access the same element:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">numbers</span>[<span class="js-id">i</span>]
<span class="js-op">*(</span><span class="js-id">numbers</span> <span class="js-op">+</span> <span class="js-id">i</span><span class="js-op">)</span></code></pre></div><p><strong>Important:</strong> An array and a pointer are not the same thing. An array has its own fixed size and storage, while a pointer is a separate variable that stores an address.</p><h2>9. Pointer to Pointer in C++</h2><p>A pointer to pointer stores the address of another pointer.</p><p>It is also called a double pointer.</p><h3>Syntax</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">data_type</span><span class="js-op">**</span> <span class="js-id">pointer_name</span><span class="js-op">;</span></code></pre></div><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-num">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">=</span> <span class="js-op">&</span><span class="js-id">number</span><span class="js-op">;</span>
<span class="js-id">int</span><span class="js-op">**</span> <span class="js-id">doublePtr</span> <span class="js-op">=</span> <span class="js-op">&</span><span class="js-id">ptr</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Value: "</span> <span class="js-op"><<</span> <span class="js-id">number</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Using pointer: "</span> <span class="js-op"><<</span> <span class="js-op">*</span><span class="js-id">ptr</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Using double pointer: "</span> <span class="js-op"><<</span> <span class="js-op">**</span><span class="js-id">doublePtr</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Value</span><span class="js-op">:</span> <span class="js-num">100</span>
<span class="js-id">Using</span> <span class="js-id">pointer</span><span class="js-op">:</span> <span class="js-num">100</span>
<span class="js-id">Using</span> <span class="js-id">double</span> <span class="js-id">pointer</span><span class="js-op">:</span> <span class="js-num">100</span></code></pre></div><h3>How does it work?</h3><ul><li><p><code>number</code> stores <code>100</code>.</p></li><li><p><code>ptr</code> stores the address of <code>number</code>.</p></li><li><p><code>doublePtr</code> stores the address of <code>ptr</code>.</p></li><li><p><code>**doublePtr</code> accesses the original integer value.</p></li></ul><p>Double pointers are useful in certain dynamic data structures and when a function needs to modify a pointer variable itself.</p><h2>10. Pointers and Functions</h2><p>Pointers can be passed to functions to allow a function to access or modify the original variable.</p><h3>Example: Passing a pointer to a function</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-kw">void</span> <span class="js-id">updateValue</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">)</span> <span class="js-op">{</span>
<span class="js-kw">if</span> <span class="js-op">(</span><span class="js-id">ptr</span> <span class="js-op">!=</span> <span class="js-id">nullptr</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-op">*</span><span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-num">500</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">}</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</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-id">updateValue</span><span class="js-op">(&</span><span class="js-id">number</span><span class="js-op">);</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">number</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">500</span></code></pre></div><h3>Explanation</h3><ul><li><p><code>&number</code> passes the address of the original variable.</p></li><li><p><code>int* ptr</code> receives that address.</p></li><li><p><code>*ptr = 500</code> modifies the original variable.</p></li><li><p>The updated value is visible in <code>main()</code>.</p></li></ul><p>For many ordinary C++ functions, references are simpler and safer when you only need to modify an existing object. Pointers are useful when an optional object or explicit address-based behavior is needed.</p><h2>11. Dynamic Memory Allocation Using Pointers</h2><p>C++ allows memory to be allocated dynamically while a program is running.</p><p>The <code>new</code> operator allocates memory, and <code>delete</code> releases memory allocated with <code>new</code>.</p><h3>Example: Using new and delete</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span><span class="js-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-op">*</span><span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-num">200</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-str">"Value: "</span> <span class="js-op"><<</span> <span class="js-op">*</span><span class="js-id">ptr</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">delete</span> <span class="js-id">ptr</span><span class="js-op">;</span>
<span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-id">nullptr</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">Value</span><span class="js-op">:</span> <span class="js-num">200</span></code></pre></div><h3>Explanation</h3><ol start="1"><li><p><code>new int</code> allocates memory for one integer.</p></li><li><p>The returned address is stored in <code>ptr</code>.</p></li><li><p><code>*ptr = 200</code> stores a value in the allocated memory.</p></li><li><p><code>delete ptr</code> releases that memory.</p></li><li><p><code>ptr = nullptr</code> prevents the pointer from retaining a stale address.</p></li></ol><h3>Dynamic array allocation</h3><p>You can also allocate an array dynamically.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">size</span> <span class="js-op">=</span> <span class="js-num">3</span><span class="js-op">;</span>
<span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">numbers</span> <span class="js-op">=</span> <span class="js-kw">new</span> <span class="js-id">int</span>[<span class="js-id">size</span>]<span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">20</span><span class="js-op">,</span> <span class="js-num">30</span><span class="js-op">};</span>
<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"><</span> <span class="js-id">size</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">cout</span> <span class="js-op"><<</span> <span class="js-id">numbers</span>[<span class="js-id">i</span>] <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-id">delete</span>[] <span class="js-id">numbers</span><span class="js-op">;</span>
<span class="js-id">numbers</span> <span class="js-op">=</span> <span class="js-id">nullptr</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span>
<span class="js-num">20</span>
<span class="js-num">30</span></code></pre></div><p>Use <code>delete[]</code> for memory allocated with <code>new[]</code>. Using the wrong form of delete results in undefined behavior.</p><h3>Modern C++ recommendation</h3><p>In modern C++, prefer standard library containers such as <code>std::vector</code> for dynamic arrays and smart pointers such as <code>std::unique_ptr</code> or <code>std::shared_ptr</code> for managed dynamic objects.</p><p>These tools help reduce memory leaks and ownership errors.</p><h2>12. Constant Pointers and Pointers to Constants</h2><p>C++ provides different ways to use <code>const</code> with pointers.</p><h3>Pointer to a constant value</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-kw">const</span> <span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span><span class="js-op">;</span></code></pre></div><p>You cannot modify the pointed-to value through this pointer, but you can make the pointer point somewhere else.</p><h3>Constant pointer</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span><span class="js-op">*</span> <span class="js-kw">const</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&</span><span class="js-id">number</span><span class="js-op">;</span></code></pre></div><p>The pointer cannot be made to point to another address, but the pointed-to value can be modified through it.</p><h3>Constant pointer to a constant value</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-kw">const</span> <span class="js-id">int</span><span class="js-op">*</span> <span class="js-kw">const</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&</span><span class="js-id">number</span><span class="js-op">;</span></code></pre></div><p>Neither the pointer nor the pointed-to value can be modified through this pointer.</p><h3>Comparison</h3><table><tbody><tr><th>Declaration</th><th>Change pointer address?</th><th>Modify value through pointer?</th></tr><tr><td><code>int* ptr</code></td><td>Yes</td><td>Yes</td></tr><tr><td><code>const int* ptr</code></td><td>Yes</td><td>No</td></tr><tr><td><code>int* const ptr</code></td><td>No</td><td>Yes</td></tr><tr><td><code>const int* const ptr</code></td><td>No</td><td>No</td></tr></tbody></table><h2>13. Void Pointers in C++</h2><p>A <code>void*</code> is a pointer type that can hold the address of an object of any object type.</p><p>However, a <code>void*</code> cannot be directly dereferenced because it does not specify the pointed-to type.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">number</span> <span class="js-op">=</span> <span class="js-num">100</span><span class="js-op">;</span>
<span class="js-kw">void</span><span class="js-op">*</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&</span><span class="js-id">number</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-op">*</span><span class="js-id">static_cast</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">)</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">100</span></code></pre></div><p>Here, <code>static_cast<int*>(ptr)</code> converts the <code>void*</code> back to an <code>int*</code> before dereferencing it.</p><p>The cast must match the actual object type. A <code>void*</code> is not a replacement for type-safe pointers in ordinary C++ code.</p><h2>14. Function Pointers in C++</h2><p>A function pointer stores the address of a function. It allows a function to be called indirectly through a pointer.</p><h3>Syntax</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">return_type</span> <span class="js-op">(*</span><span class="js-id">pointer_name</span><span class="js-op">)(</span><span class="js-id">parameter_types</span><span class="js-op">);</span></code></pre></div><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">int</span> <span class="js-id">add</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">a</span><span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">b</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">return</span> <span class="js-id">a</span> <span class="js-op">+</span> <span class="js-id">b</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">int</span> <span class="js-op">(*</span><span class="js-id">operation</span><span class="js-op">)(</span><span class="js-id">int</span><span class="js-op">,</span> <span class="js-id">int</span><span class="js-op">)</span> <span class="js-op">=</span> <span class="js-id">add</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">operation</span><span class="js-op">(</span><span class="js-num">10</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">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">30</span></code></pre></div><h3>Explanation</h3><ul><li><p><code>add()</code> is a function that accepts two integers.</p></li><li><p><code>operation</code> is a pointer to a function with a matching signature.</p></li><li><p><code>operation(10, 20)</code> calls the function through the pointer.</p></li></ul><p>Function pointers are useful for callbacks, selecting operations, and working with some C and C++ APIs.</p><h2>15. Practical Uses of Pointers in C++</h2><p>Pointers are used in many areas of C++ programming.</p><table><tbody><tr><th>Use case</th><th>How pointers help</th></tr><tr><td>Dynamic memory</td><td>Manage objects created during program execution</td></tr><tr><td>Arrays</td><td>Access and process array elements</td></tr><tr><td>Functions</td><td>Pass addresses and modify original objects</td></tr><tr><td>Linked lists</td><td>Connect nodes in a data structure</td></tr><tr><td>Trees</td><td>Link parent and child nodes</td></tr><tr><td>Polymorphism</td><td>Use base-class pointers to access derived objects</td></tr><tr><td>Function callbacks</td><td>Call functions indirectly</td></tr><tr><td>System programming</td><td>Work with memory and low-level interfaces</td></tr></tbody></table><h3>Example: Using pointers in a linked-list node</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-id">struct</span> <span class="js-id">Node</span> <span class="js-op">{</span>
<span class="js-id">int</span> <span class="js-id">data</span><span class="js-op">;</span>
<span class="js-id">Node</span><span class="js-op">*</span> <span class="js-id">next</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">Node</span> <span class="js-id">first</span><span class="js-op">{</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-id">nullptr</span><span class="js-op">};</span>
<span class="js-id">Node</span> <span class="js-id">second</span><span class="js-op">{</span><span class="js-num">20</span><span class="js-op">,</span> <span class="js-id">nullptr</span><span class="js-op">};</span>
<span class="js-id">first</span><span class="js-op">.</span><span class="js-id">next</span> <span class="js-op">=</span> <span class="js-op">&</span><span class="js-id">second</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">first</span><span class="js-op">.</span><span class="js-id">data</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">first</span><span class="js-op">.</span><span class="js-id">next</span><span class="js-op">-></span><span class="js-id">data</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">10</span>
<span class="js-num">20</span></code></pre></div><p>The <code>next</code> pointer connects the first node to the second node. This is a basic example of how pointers are used to build linked lists.</p><h2>16. Common Pointer Errors in C++</h2><p>Pointers are powerful, but incorrect pointer usage can cause serious programming errors.</p><h3>1. Uninitialized pointer</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span><span class="js-op">;</span>
<span class="js-cm">// Dangerous: ptr does not point to a known object.</span></code></pre></div><p><strong>Solution:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-id">nullptr</span><span class="js-op">;</span></code></pre></div><h3>2. Dereferencing a null pointer</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span><span class="js-op">*</span> <span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-id">nullptr</span><span class="js-op">;</span>
<span class="js-cm">// Dangerous: *ptr = 10;</span></code></pre></div><p><strong>Solution:</strong> Check whether a pointer is non-null before dereferencing it.</p><h3>3. Dangling pointer</h3><p>A dangling pointer refers to an object whose lifetime has ended.</p><p>For example, returning the address of a local variable from a function creates a dangling pointer.</p><p><strong>Solution:</strong> Do not use pointers after the pointed-to object's lifetime ends. Use appropriate ownership tools.</p><h3>4. Memory leak</h3><p>A memory leak occurs when dynamically allocated memory is not released and no longer has a usable owner.</p><p><strong>Solution:</strong> Prefer RAII and smart pointers, or ensure every allocation is correctly released.</p><h3>5. Double deletion</h3><p>Deleting the same dynamically allocated object more than once causes undefined behavior.</p><p><strong>Solution:</strong> Use clear ownership rules and prefer smart pointers.</p><h3>6. Accessing memory outside an array</h3><p>Pointer arithmetic beyond an array's valid range can cause undefined behavior.</p><p><strong>Solution:</strong> Keep pointer operations within the array or its one-past position, and never dereference the one-past pointer.</p><h2>17. Pointers vs References in C++</h2><p>Pointers and references both allow indirect access to objects, but they have different properties.</p><table><tbody><tr><th>Feature</th><th>Pointer</th><th>Reference</th></tr><tr><td>Declaration</td><td>Uses <code>*</code></td><td>Uses <code>&</code></td></tr><tr><td>Initialization</td><td>Can be initialized later</td><td>Must be initialized when declared</td></tr><tr><td>Null state</td><td>Can be <code>nullptr</code></td><td>Cannot be a null reference in normal valid use</td></tr><tr><td>Reassignment</td><td>Can point to another object</td><td>Cannot be reseated to another object</td></tr><tr><td>Access</td><td>Uses <code>*</code> to dereference</td><td>Used like the original variable</td></tr><tr><td>Arithmetic</td><td>Supported for suitable pointers</td><td>Not supported</td></tr><tr><td>Typical use</td><td>Optional objects and address-based operations</td><td>Required object parameters and aliases</td></tr></tbody></table><h3>Example using a reference</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op"><</span><span class="js-id">iostream</span><span class="js-op">></span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>
<span class="js-kw">void</span> <span class="js-id">update</span><span class="js-op">(</span><span class="js-id">int</span><span class="js-op">&</span> <span class="js-id">value</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-id">value</span> <span class="js-op">=</span> <span class="js-num">500</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">int</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-id">update</span><span class="js-op">(</span><span class="js-id">number</span><span class="js-op">);</span>
<span class="js-id">cout</span> <span class="js-op"><<</span> <span class="js-id">number</span> <span class="js-op"><<</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-num">0</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Output:</strong></p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-num">500</span></code></pre></div><p>References are often a simpler choice when a function requires an existing object. Pointers are appropriate when the address itself or an optional object matters.</p><h2>18. Best Practices for Using Pointers</h2><p>Follow these practices when writing pointer-based C++ programs:</p><ol start="1"><li><p>Initialize pointers before using them.</p></li><li><p>Use <code>nullptr</code> to represent an empty pointer.</p></li><li><p>Never dereference a null, dangling, or otherwise invalid pointer.</p></li><li><p>Avoid unnecessary manual memory allocation.</p></li><li><p>Prefer <code>std::vector</code> for dynamic arrays.</p></li><li><p>Prefer <code>std::unique_ptr</code> for exclusive dynamic ownership.</p></li><li><p>Use <code>std::shared_ptr</code> only when shared ownership is genuinely required.</p></li><li><p>Match <code>new</code> with <code>delete</code> and <code>new[]</code> with <code>delete[]</code>.</p></li><li><p>Avoid returning pointers to local variables.</p></li><li><p>Keep pointer ownership and object lifetimes clear.</p></li></ol><h2>19. Frequently Asked Questions (FAQs)</h2><h3>Q1. What is a pointer in C++?</h3><p>A pointer is a variable that stores the memory address of another object or function.</p><h3>Q2. What is the use of a pointer?</h3><p>Pointers are used for dynamic memory management, arrays, functions, linked lists, trees, polymorphism, and low-level programming.</p><h3>Q3. What does the * operator mean in C++?</h3><p>The <code>*</code> operator is used to declare a pointer and to dereference a pointer to access the object it points to.</p><h3>Q4. What does the & operator mean in C++?</h3><p>The <code>&</code> operator obtains the address of an object. It is also used in reference declarations, depending on its context.</p><h3>Q5. What is a null pointer?</h3><p>A null pointer does not point to a valid object or function. In modern C++, use <code>nullptr</code> to represent one.</p><h3>Q6. What is pointer arithmetic?</h3><p>Pointer arithmetic is the process of moving a pointer between elements of the same array, using operations such as <code>ptr++</code> and <code>ptr + n</code>.</p><h3>Q7. What is a double pointer?</h3><p>A double pointer is a pointer that stores the address of another pointer. It is declared using two asterisks, such as <code>int** ptr</code>.</p><h3>Q8. What is dynamic memory allocation?</h3><p>Dynamic memory allocation allows a program to request memory during execution. C++ provides <code>new</code> and <code>delete</code>, while modern C++ also offers containers and smart pointers.</p><h3>Q9. What is a dangling pointer?</h3><p>A dangling pointer refers to an object whose lifetime has ended or whose storage is no longer valid for access.</p><h3>Q10. Are pointers and arrays the same in C++?</h3><p>No. Array names convert to pointers in many expressions, but arrays and pointers are different types with different properties.</p>
Code Example
#include <iostream>
void modifyViaPointer(int* ptr) {
if (ptr != nullptr) {
*ptr = 999; // Dereference and write
}
}
int main() {
int sensorData = 100;
int* ptr = &sensorData; // Store address
std::cout << "Original Value: " << sensorData << "
";
std::cout << "Memory Address: " << ptr << "
";
std::cout << "Dereferenced: " << *ptr << "
";
modifyViaPointer(ptr);
std::cout << "After modification: " << sensorData << "
";
return 0;
}Interview Question & Tips
A: `NULL` is an integer macro (`0` or `0L`), causing overload resolution ambiguities between `f(int)` and `f(int*)`. `nullptr` is a distinct keyword with type `std::nullptr_t` that safely converts only to pointer types.
Q: What is a dangling pointer?
A: A pointer that still holds the memory address of an object that has already been deallocated or gone out of scope. Dereferencing a dangling pointer produces undefined behavior / memory corruption.
Best Practices
2. Check pointers for `nullptr` before dereferencing.
3. Use smart pointers (`std::unique_ptr`) to eliminate raw ownership pointers.
This study reference for Pointers in C++: Memory Addresses, Dereferencing, and Practical Uses is curated and verified against recognized curriculum benchmarks, peer-reviewed textbooks, and official technical documentation: