C++ Programming 4. Functions in C++ 16 mins read 23,806 views

Function Overriding in C++: Redefining Inherited Behavior

Function overriding is an important concept in C++ object-oriented programming. It allows a derived class to provide its own implementation of a function that i...
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 Function Overriding in C++: Redefining Inherited Behavior? Function overriding is an important concept in C++ object-oriented programming. It allows a derived class to provide its own implementation of a function that i...

Audience & Scope: Students, educators, and candidates preparing for academic examinations and technical assessments in C++ Programming.
How does function overriding implement runtime polymorphism using virtual functions in C++?
<p data-pm-slice="1 1 []">Function overriding is an important concept in C++ object-oriented programming. It allows a derived class to provide its own implementation of a function that is already defined in its base class.</p><p data-pm-slice="1 1 []"><br></p><p>This feature is especially useful when different classes need to perform the same operation in different ways. For example, different animals can make different sounds, even though they all share a common <code dir="ltr">makeSound()</code> function.</p>

Explanation & In-Depth Details

<h2 class="h4 fw-bold text-dark mb-3"><span style="font-size: 1.15rem;">1. What Is Function Overriding in C++?</span></h2><p>Function overriding occurs when a derived class provides its own implementation of a virtual member function inherited from a base class.</p><p>The overriding function generally has the same name and matching parameter list as the base class function. Its return type must also be compatible with the base function's return type.</p><h3>Simple example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Animal</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">virtual</span> <span class="js-kw">void</span> <span class="js-id">makeSound</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Animal makes a sound"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Dog</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Animal</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">makeSound</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Dog barks"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-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">Dog</span> <span class="js-id">d</span><span class="js-op">;</span>
<span class="js-id">d</span><span class="js-op">.</span><span class="js-id">makeSound</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">Dog</span> <span class="js-id">barks</span></code></pre></div><h3>Explanation</h3><ul><li><p><code>Animal</code> is the base class.</p></li><li><p><code>Dog</code> is the derived class.</p></li><li><p>The base class defines the <code>makeSound()</code> function.</p></li><li><p>The derived class provides a different implementation.</p></li><li><p>The <code>virtual</code> keyword enables runtime dispatch through base-class pointers or references.</p></li><li><p>The <code>override</code> keyword tells the compiler that the derived function is intended to override a virtual base-class function.</p></li></ul><h2>2. Syntax of Function Overriding</h2><p>The general syntax is:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-kw">class</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">virtual</span> <span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-cm">// Base class implementation</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Derived</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-cm">// Derived class implementation</span>
<span class="js-op">}</span>
<span class="js-op">};</span></code></pre></div><p><strong>Important points:</strong></p><ol start="1"><li><p>The base class function must be virtual for runtime overriding.</p></li><li><p>The derived class provides a matching function.</p></li><li><p>The <code>override</code> keyword is optional but strongly recommended.</p></li><li><p>The overriding function can contain completely different statements.</p></li><li><p>The function is selected at runtime when called through a base-class pointer or reference.</p></li></ol><h2>3. Understanding the virtual Keyword</h2><p>The <code>virtual</code> keyword tells C++ that a member function can be overridden in a derived class.</p><p>It enables dynamic binding, also called runtime polymorphism.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Parent</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">virtual</span> <span class="js-kw">void</span> <span class="js-id">show</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Parent class function"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Child</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Parent</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">show</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Child class function"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-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">Parent</span> <span class="js-id">p</span><span class="js-op">;</span>
<span class="js-id">Child</span> <span class="js-id">c</span><span class="js-op">;</span>

<span class="js-id">p</span><span class="js-op">.</span><span class="js-id">show</span><span class="js-op">();</span>
<span class="js-id">c</span><span class="js-op">.</span><span class="js-id">show</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">Parent</span> <span class="js-kw">class</span> <span class="js-kw">function</span>
<span class="js-id">Child</span> <span class="js-kw">class</span> <span class="js-kw">function</span></code></pre></div><p>The base-class object calls the base implementation, while the derived-class object calls the overridden implementation.</p><h2>4. Function Overriding Using a Base Class Pointer</h2><p>One of the most important benefits of overriding is that a base-class pointer can call the derived-class implementation.</p><p>This is an example of runtime polymorphism.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Animal</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">virtual</span> <span class="js-kw">void</span> <span class="js-id">sound</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Animal makes a sound"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Cat</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Animal</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">sound</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Cat says Meow"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-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">Animal</span><span class="js-op">*</span> <span class="js-id">ptr</span><span class="js-op">;</span>

<span class="js-id">Cat</span> <span class="js-id">c</span><span class="js-op">;</span>

<span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&amp;</span><span class="js-id">c</span><span class="js-op">;</span>

<span class="js-id">ptr</span><span class="js-op">-&gt;</span><span class="js-id">sound</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">Cat</span> <span class="js-id">says</span> <span class="js-id">Meow</span></code></pre></div><h3>How does it work?</h3><ol start="1"><li><p><code>ptr</code> is a pointer to the base class <code>Animal</code>.</p></li><li><p>The pointer stores the address of a <code>Cat</code> object.</p></li><li><p>The <code>sound()</code> function is virtual.</p></li><li><p>C++ checks the actual object type at runtime.</p></li><li><p>The <code>Cat</code> implementation is executed.</p></li></ol><p>This behavior is called <strong>dynamic binding</strong> or <strong>dynamic dispatch</strong>.</p><h2>5. Function Overriding Without the virtual Keyword</h2><p>If a base-class function is not virtual, defining a function with the same signature in a derived class does not provide runtime polymorphism.</p><p>The derived function hides the base function for ordinary name lookup in the derived class.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Base class function"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Derived</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Derived class function"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-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">Base</span><span class="js-op">*</span> <span class="js-id">ptr</span><span class="js-op">;</span>

<span class="js-id">Derived</span> <span class="js-id">d</span><span class="js-op">;</span>
<span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&amp;</span><span class="js-id">d</span><span class="js-op">;</span>

<span class="js-id">ptr</span><span class="js-op">-&gt;</span><span class="js-id">display</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">Base</span> <span class="js-kw">class</span> <span class="js-kw">function</span></code></pre></div><h3>Why?</h3><p>The base-class function is not virtual. Therefore, the function call through <code>Base*</code> is resolved using the pointer's declared type.</p><p><strong>Remember:</strong> For runtime function overriding, declare the base-class function as <code>virtual</code>.</p><h2>6. Understanding the override Keyword</h2><p>The <code>override</code> keyword is available in modern C++ (C++11 and later).</p><p>It explicitly tells the compiler that a derived-class function must override a virtual function from a base class.</p><p>If the function does not match a virtual base-class function, the compiler reports an error.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">virtual</span> <span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Base display"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Derived</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Derived display"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-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">Derived</span> <span class="js-id">d</span><span class="js-op">;</span>
<span class="js-id">d</span><span class="js-op">.</span><span class="js-id">display</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">Derived</span> <span class="js-id">display</span></code></pre></div><h3>Why should you use override?</h3><ul><li><p>It catches mistakes in function signatures.</p></li><li><p>It makes the programmer's intention clear.</p></li><li><p>It helps prevent accidental function hiding.</p></li><li><p>It improves code readability and maintainability.</p></li></ul><p>For example, if the base function accepts an <code>int</code>, but the derived function accidentally accepts a <code>double</code>, <code>override</code> helps the compiler identify the mismatch.</p><h2>7. Multiple Classes Using Function Overriding</h2><p>A base class can have multiple derived classes, and each derived class can implement the same virtual function differently.</p><h3>Example: Animal sounds</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Animal</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">virtual</span> <span class="js-kw">void</span> <span class="js-id">sound</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Animal makes a sound"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Dog</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Animal</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">sound</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Dog barks"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Cat</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Animal</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">sound</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Cat meows"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Cow</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Animal</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">sound</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Cow moos"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-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">Dog</span> <span class="js-id">d</span><span class="js-op">;</span>
<span class="js-id">Cat</span> <span class="js-id">c</span><span class="js-op">;</span>
<span class="js-id">Cow</span> <span class="js-id">cow</span><span class="js-op">;</span>

<span class="js-id">Animal</span><span class="js-op">*</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-op">&amp;</span><span class="js-id">d</span><span class="js-op">;</span>
<span class="js-id">ptr</span><span class="js-op">-&gt;</span><span class="js-id">sound</span><span class="js-op">();</span>

<span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&amp;</span><span class="js-id">c</span><span class="js-op">;</span>
<span class="js-id">ptr</span><span class="js-op">-&gt;</span><span class="js-id">sound</span><span class="js-op">();</span>

<span class="js-id">ptr</span> <span class="js-op">=</span> <span class="js-op">&amp;</span><span class="js-id">cow</span><span class="js-op">;</span>
<span class="js-id">ptr</span><span class="js-op">-&gt;</span><span class="js-id">sound</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">Dog</span> <span class="js-id">barks</span>
<span class="js-id">Cat</span> <span class="js-id">meows</span>
<span class="js-id">Cow</span> <span class="js-id">moos</span></code></pre></div><p>Each derived object provides its own implementation of the same function.</p><p>This is a practical example of runtime polymorphism.</p><h2>8. Calling the Base Class Function From an Overridden Function</h2><p>Sometimes a derived class needs to execute the base-class implementation before or after its own implementation.</p><p>You can use the scope resolution operator <code>::</code> to call the base-class function.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">virtual</span> <span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Base class display"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Derived</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-id">Base</span><span class="js-op">::</span><span class="js-id">display</span><span class="js-op">();</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Derived class display"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-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">Derived</span> <span class="js-id">d</span><span class="js-op">;</span>
<span class="js-id">d</span><span class="js-op">.</span><span class="js-id">display</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">Base</span> <span class="js-kw">class</span> <span class="js-id">display</span>
<span class="js-id">Derived</span> <span class="js-kw">class</span> <span class="js-id">display</span></code></pre></div><p>Here, <code>Base::display()</code> explicitly calls the base-class implementation.</p><h2>9. Function Overriding With a Virtual Destructor</h2><p>When a class is designed to be used polymorphically, its destructor should generally be virtual.</p><p>This ensures that deleting a derived object through a base-class pointer invokes the derived-class destructor as well as the base-class destructor.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">virtual</span> <span class="js-op">~</span><span class="js-id">Base</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Base destructor"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Derived</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-op">~</span><span class="js-id">Derived</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Derived destructor"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-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">Base</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">Derived</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-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">Derived</span> <span class="js-id">destructor</span>
<span class="js-id">Base</span> <span class="js-id">destructor</span></code></pre></div><p><strong>Important:</strong> If you plan to delete derived objects through base-class pointers, use a virtual base-class destructor. Otherwise, deleting through that pointer has undefined behavior.</p><h2>10. Rules of Function Overriding in C++</h2><p>Keep these important rules in mind:</p><ol start="1"><li><p>The base-class function must be virtual for runtime overriding.</p></li><li><p>The derived function must have a matching parameter list.</p></li><li><p>The overriding function must have a compatible return type.</p></li><li><p>The function cannot be overridden if it is declared <code>final</code>.</p></li><li><p>The <code>override</code> keyword is optional, but recommended.</p></li><li><p>The overriding function cannot have a more restrictive access level as a general requirement; C++ permits different access levels, although public access is commonly used.</p></li><li><p>Constructors cannot be virtual or overridden.</p></li><li><p>Destructors can be virtual and are commonly made virtual in polymorphic base classes.</p></li><li><p>A virtual function can be overridden through multiple levels of inheritance.</p></li><li><p>A derived-class function can explicitly call the base implementation using <code>Base::functionName()</code>.</p></li></ol><h3>Return type compatibility</h3><p>An overriding function normally uses the same return type as the virtual base function. C++ also permits certain covariant return types for pointers and references to related class types.</p><p>Example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-kw">class</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">virtual</span> <span class="js-id">Base</span><span class="js-op">*</span> <span class="js-id">create</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-kw">return</span> <span class="js-kw">this</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Derived</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">Derived</span><span class="js-op">*</span> <span class="js-id">create</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-kw">return</span> <span class="js-kw">this</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span></code></pre></div><p>Here, <code>Derived*</code> is a valid covariant return type because <code>Derived</code> is publicly derived from <code>Base</code>.</p><h2>11. The final Keyword in Function Overriding</h2><p>C++11 introduced the <code>final</code> keyword to prevent further overriding of a virtual function.</p><h3>Example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">virtual</span> <span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">()</span> <span class="js-id">final</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Base display"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Derived</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Base</span> <span class="js-op">{</span>
<span class="js-cm">// void display() override; // Compilation error</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">Derived</span> <span class="js-id">d</span><span class="js-op">;</span>
<span class="js-id">d</span><span class="js-op">.</span><span class="js-id">display</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">Base</span> <span class="js-id">display</span></code></pre></div><p>The <code>display()</code> function is marked <code>final</code>, so a derived class cannot override it.</p><p>You can also mark an entire class as <code>final</code> to prevent inheritance from that class.</p><h2>12. Function Overriding vs Function Overloading</h2><p>Function overriding and function overloading are two different C++ concepts.</p><table><tbody><tr><th>Feature</th><th>Function Overriding</th><th>Function Overloading</th></tr><tr><td>Meaning</td><td>Redefines inherited virtual behavior</td><td>Uses the same function name with different parameters</td></tr><tr><td>Classes</td><td>Requires inheritance</td><td>Can occur within one class</td></tr><tr><td>Parameters</td><td>Must match the base function's parameter list</td><td>Must differ in a valid way</td></tr><tr><td>Virtual keyword</td><td>Required for runtime overriding</td><td>Not required</td></tr><tr><td>Binding</td><td>Runtime when called virtually</td><td>Usually compile time</td></tr><tr><td>Purpose</td><td>Runtime polymorphism</td><td>Compile-time polymorphism</td></tr></tbody></table><h3>Overloading example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Calculator</span> <span class="js-op">{</span>
<span class="js-id">public</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">double</span> <span class="js-id">add</span><span class="js-op">(</span><span class="js-id">double</span> <span class="js-id">a</span><span class="js-op">,</span> <span class="js-id">double</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-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">Calculator</span> <span class="js-id">c</span><span class="js-op">;</span>

<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">c</span><span class="js-op">.</span><span class="js-id">add</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">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">c</span><span class="js-op">.</span><span class="js-id">add</span><span class="js-op">(</span><span class="js-num">5.5</span><span class="js-op">,</span> <span class="js-num">2.5</span><span class="js-op">)</span> <span class="js-op">&lt;&lt;</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>
<span class="js-num">8</span></code></pre></div><h3>Overriding example</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">class</span> <span class="js-id">Parent</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-id">virtual</span> <span class="js-kw">void</span> <span class="js-id">show</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Parent class"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-op">};</span>

<span class="js-kw">class</span> <span class="js-id">Child</span> <span class="js-op">:</span> <span class="js-id">public</span> <span class="js-id">Parent</span> <span class="js-op">{</span>
<span class="js-id">public</span><span class="js-op">:</span>
<span class="js-kw">void</span> <span class="js-id">show</span><span class="js-op">()</span> <span class="js-id">override</span> <span class="js-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Child class"</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>
<span class="js-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">Child</span> <span class="js-id">c</span><span class="js-op">;</span>
<span class="js-id">c</span><span class="js-op">.</span><span class="js-id">show</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">Child</span> <span class="js-kw">class</span></code></pre></div><h2>13. Advantages of Function Overriding</h2><p>Function overriding offers several benefits in object-oriented programming.</p><ul><li><p><strong>Runtime polymorphism:</strong> The correct implementation can be selected at runtime.</p></li><li><p><strong>Code reusability:</strong> Derived classes can reuse the base-class structure.</p></li><li><p><strong>Flexibility:</strong> Different derived classes can implement the same operation differently.</p></li><li><p><strong>Extensibility:</strong> New derived classes can be added without changing code that works with the base-class interface.</p></li><li><p><strong>Maintainability:</strong> Shared behavior can be organized in a common base class.</p></li></ul><h2>14. Common Mistakes in Function Overriding</h2><p>Beginners often make these mistakes:</p><p><strong>1. Forgetting the virtual keyword</strong></p><p>Without a virtual base-class function, calls through base pointers do not use runtime dispatch.</p><p><strong>2. Using different parameter types</strong></p><p>A function with a different parameter list may hide the base function instead of overriding it.</p><p><strong>3. Forgetting override</strong></p><p>The compiler may not catch an unintended function declaration as an overriding mistake unless <code>override</code> is specified.</p><p><strong>4. Confusing overriding with overloading</strong></p><p>Overriding involves inherited virtual functions, while overloading involves multiple function signatures.</p><p><strong>5. Forgetting a virtual destructor</strong></p><p>Deleting a derived object through a base-class pointer requires a virtual base-class destructor.</p><p><strong>6. Assuming virtual functions are always expanded at runtime</strong></p><p>Virtual dispatch is based on the object's dynamic type when called through a base pointer or reference. Calls on objects and some qualified calls can be resolved directly.</p><h2>15. Best Practices for Function Overriding</h2><ul><li><p>Use <code>virtual</code> for base-class functions that should support runtime polymorphism.</p></li><li><p>Use <code>override</code> for derived-class functions intended to override a base function.</p></li><li><p>Use <code>final</code> when further overriding should not be allowed.</p></li><li><p>Give polymorphic base classes virtual destructors.</p></li><li><p>Keep function names and responsibilities clear.</p></li><li><p>Avoid unnecessary inheritance when composition is a better design.</p></li><li><p>Test derived classes through base-class pointers and references.</p></li></ul><h2>16. Frequently Asked Questions (FAQs)</h2><h3>Q1. What is function overriding in C++?</h3><p>Function overriding is when a derived class provides its own implementation of an inherited virtual function from a base class.</p><h3>Q2. Is the virtual keyword necessary for function overriding?</h3><p>The <code>virtual</code> keyword is necessary in the base class for runtime polymorphic overriding. A derived function with the same name and signature can exist without it, but calls through a base pointer or reference will not use virtual dispatch.</p><h3>Q3. What is the use of the override keyword?</h3><p>The <code>override</code> keyword tells the compiler that a derived function is intended to override a virtual base-class function. It helps detect signature mistakes.</p><h3>Q4. Can we override a non-virtual function in C++?</h3><p>A derived class can define a function with the same name and signature as a non-virtual base function, but this is function hiding, not runtime overriding.</p><h3>Q5. What is runtime polymorphism?</h3><p>Runtime polymorphism allows C++ to select the appropriate overridden virtual function based on the actual object type at runtime.</p><h3>Q6. Can constructors be overridden?</h3><p>No. Constructors are not inherited as virtual functions and cannot be overridden. Destructors, however, can be virtual.</p><h3>Q7. Can a virtual function be private?</h3><p>Yes. A private virtual function can be overridden in a derived class. Access control affects whether a function can be called directly, not whether it can be overridden.</p><h3>Q8. What is the difference between virtual and override?</h3><p><code>virtual</code> declares a base-class function as virtual. <code>override</code> marks a derived-class function as an intended override and makes the compiler check it.</p><h3>Q9. Can we prevent function overriding?</h3><p>Yes. Use the <code>final</code> keyword on a virtual function to prevent derived classes from overriding it.</p><h3>Q10. Does function overriding support multiple inheritance?</h3><p>Yes. C++ supports virtual function overriding with multiple inheritance, although ambiguous or repeated base-class structures require careful design.</p>

Code Example

#include <iostream>
#include <memory>

class GraphicShape {
public:
    virtual ~GraphicShape() = default; // Virtual destructor mandatory for polymorphism

    virtual void draw() const {
        std::cout << "Drawing generic shape
";
    }
};

class Circle : public GraphicShape {
public:
    void draw() const override { // C++11 override specifier
        std::cout << "Drawing precise vector Circle (radius: 10)
";
    }
};

int main() {
    std::unique_ptr<GraphicShape> shape = std::make_unique<Circle>();
    shape->draw(); // Dynamically dispatches to Circle::draw()
    return 0;
}

Interview Question & Tips

Q: Why is a virtual destructor mandatory when using function overriding?
A: If a base class pointer pointing to a derived object is deleted without a virtual destructor, only the base class destructor runs, causing resource leaks (slicing / leaked derived class members).

Q: What is the difference between function overloading and function overriding?
A: Overloading occurs in the same scope with different parameters resolved at compile-time. Overriding occurs across inherited classes with identical signatures resolved dynamically at runtime via vtables.

Best Practices

1. Always mark overridden member functions with the `override` specifier.
2. Always declare a `virtual ~Base() = default;` destructor in polymorphic base classes.
3. Use `final` when a class or virtual function is not intended to be further extended.
Academic Standards & Verified Citations

This study reference for Function Overriding in C++: Redefining Inherited Behavior is curated and verified against recognized curriculum benchmarks, peer-reviewed textbooks, and official technical documentation:

C++ Programming