C++ Programming 4. Functions in C++ 14 mins read 21,206 views

Function Overloading in C++: Multiple Signatures for One Function Name

Function overloading is an important feature of C++ that allows you to create multiple functions with the same name but different parameter lists.Instead of cre...
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 Overloading in C++: Multiple Signatures for One Function Name? Function overloading is an important feature of C++ that allows you to create multiple functions with the same name but different parameter lists.Instead of cre...

Audience & Scope: Students, educators, and candidates preparing for academic examinations and technical assessments in C++ Programming.
How does C++ perform compile-time function overload resolution using name mangling?
<p data-pm-slice="1 1 []">Function overloading is an important feature of C++ that allows you to create multiple functions with the same name but different parameter lists.</p><p data-pm-slice="1 1 []"><br></p><p>Instead of creating separate names for similar operations, you can use one meaningful function name for different types or numbers of inputs.</p><p><br></p><p>For example, you can create an <code dir="ltr">add()</code> function that adds two integers, two floating-point numbers, or three numbers. The C++ compiler selects the appropriate function based on the arguments supplied when the function is called.</p>

Explanation & In-Depth Details

<h2 class="h4 fw-bold text-dark mb-3"><span style="font-size: 1.15rem;">1. What Is Function Overloading in C++?</span></h2><p>Function overloading is a feature of C++ that allows multiple functions to have the same name as long as their parameter lists are different.</p><p>The functions can differ by:</p><ul><li><p>Number of parameters.</p></li><li><p>Types of parameters.</p></li><li><p>Order of parameter types.</p></li></ul><p>The compiler determines which function to execute based on the arguments passed during the function call.</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-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-id">int</span> <span class="js-id">main</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-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">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><p><strong>Explanation:</strong></p><ul><li><p>The first <code>add()</code> function accepts two integers.</p></li><li><p>The second <code>add()</code> function accepts two double values.</p></li><li><p>When <code>add(10, 20)</code> is called, the integer version is selected.</p></li><li><p>When <code>add(5.5, 2.5)</code> is called, the double version is selected.</p></li></ul><p>Both functions have the same name, but their parameter types are different.</p><h2>2. Syntax of Function Overloading</h2><p>The general structure of overloaded functions looks like this:</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">return_type</span> <span class="js-id">function_name</span><span class="js-op">(</span><span class="js-id">parameter_list</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-cm">// Function body</span>
<span class="js-op">}</span>

<span class="js-id">return_type</span> <span class="js-id">function_name</span><span class="js-op">(</span><span class="js-id">different_parameter_list</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-cm">// Function body</span>
<span class="js-op">}</span></code></pre></div><p>For example:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">calculate</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-id">double</span> <span class="js-id">calculate</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-id">int</span> <span class="js-id">calculate</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-id">int</span> <span class="js-id">c</span><span class="js-op">);</span></code></pre></div><p>All three functions have the same name, <code>calculate</code>, but their parameter lists differ.</p><p><strong>Important:</strong> Function overloading cannot be achieved by changing only the return type.</p><h2>3. Types of Function Overloading in C++</h2><p>Function overloading can be implemented in several ways.</p><h3>A. Overloading by Number of Parameters</h3><p>You can create functions with the same name but different numbers of parameters.</p><p><strong>Example:</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">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">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">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-id">int</span> <span class="js-id">c</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-id">c</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">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Two numbers: "</span> <span class="js-op">&lt;&lt;</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-str">"Three numbers: "</span> <span class="js-op">&lt;&lt;</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-num">30</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">Two</span> <span class="js-id">numbers</span><span class="js-op">:</span> <span class="js-num">30</span>
<span class="js-id">Three</span> <span class="js-id">numbers</span><span class="js-op">:</span> <span class="js-num">60</span></code></pre></div><p><strong>Explanation:</strong></p><ul><li><p><code>add(int a, int b)</code> accepts two parameters.</p></li><li><p><code>add(int a, int b, int c)</code> accepts three parameters.</p></li><li><p>The compiler selects the appropriate function based on the number of arguments.</p></li></ul><h3>B. Overloading by Parameter Types</h3><p>You can use the same function name with different parameter types.</p><p><strong>Example:</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">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">display</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-op">{</span>
<span class="js-kw">return</span> <span class="js-id">number</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-id">double</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-id">double</span> <span class="js-id">number</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">return</span> <span class="js-id">number</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">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-num">25</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">display</span><span class="js-op">(</span><span class="js-num">12.5</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">25</span>
<span class="js-num">12.5</span></code></pre></div><p><strong>Explanation:</strong></p><ul><li><p>The first function accepts an integer.</p></li><li><p>The second function accepts a double.</p></li><li><p>The compiler selects the matching function based on the argument type.</p></li></ul><h3>C. Overloading by Order of Parameters</h3><p>Functions can also be overloaded by changing the order of parameter types.</p><p><strong>Example:</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">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">void</span> <span class="js-id">show</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-id">double</span> <span class="js-id">value</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">"Integer first: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">number</span>
<span class="js-op">&lt;&lt;</span> <span class="js-str">", Double second: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">value</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">void</span> <span class="js-id">show</span><span class="js-op">(</span><span class="js-id">double</span> <span class="js-id">value</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-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Double first: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">value</span>
<span class="js-op">&lt;&lt;</span> <span class="js-str">", Integer second: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">number</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-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">show</span><span class="js-op">(</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">5.5</span><span class="js-op">);</span>
<span class="js-id">show</span><span class="js-op">(</span><span class="js-num">5.5</span><span class="js-op">,</span> <span class="js-num">10</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">Integer</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">Double</span> <span class="js-id">second</span><span class="js-op">:</span> <span class="js-num">5.5</span>
<span class="js-id">Double</span> <span class="js-id">first</span><span class="js-op">:</span> <span class="js-num">5.5</span><span class="js-op">,</span> <span class="js-id">Integer</span> <span class="js-id">second</span><span class="js-op">:</span> <span class="js-num">10</span></code></pre></div><p>The functions have the same parameter types but in a different order. Therefore, they have different parameter lists.</p><h2>4. Function Overloading With Different Data Types</h2><p>C++ allows function overloading with different built-in data types, such as <code>int</code>, <code>float</code>, <code>double</code>, and <code>char</code>.</p><h3>Example: Display Different Values</h3><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">void</span> <span class="js-id">display</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-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Integer: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">value</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-id">float</span> <span class="js-id">value</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">"Float: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">value</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-id">double</span> <span class="js-id">value</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">"Double: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">value</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-id">char</span> <span class="js-id">value</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">"Character: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">value</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-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">display</span><span class="js-op">(</span><span class="js-num">100</span><span class="js-op">);</span>
<span class="js-id">display</span><span class="js-op">(</span><span class="js-num">12</span><span class="js-op">.</span>5f<span class="js-op">);</span>
<span class="js-id">display</span><span class="js-op">(</span><span class="js-num">25.75</span><span class="js-op">);</span>
<span class="js-id">display</span><span class="js-op">(</span><span class="js-str">'A'</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">Integer</span><span class="js-op">:</span> <span class="js-num">100</span>
<span class="js-id">Float</span><span class="js-op">:</span> <span class="js-num">12.5</span>
<span class="js-id">Double</span><span class="js-op">:</span> <span class="js-num">25.75</span>
<span class="js-id">Character</span><span class="js-op">:</span> <span class="js-id">A</span></code></pre></div><p><strong>Explanation:</strong></p><p>Each function has the same name but accepts a different data type. The compiler chooses the suitable overload for each call.</p><h2>5. Function Overloading With Default Arguments</h2><p>Default arguments allow a function parameter to use a predefined value when the caller does not supply an argument.</p><p>Default arguments can be used with overloaded functions, but they must be designed carefully because they can create ambiguous function calls.</p><h3>Example: Overloaded Functions</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">void</span> <span class="js-id">show</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-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Integer: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">number</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">void</span> <span class="js-id">show</span><span class="js-op">(</span><span class="js-id">double</span> <span class="js-id">number</span><span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">count</span> <span class="js-op">=</span> <span class="js-num">1</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">"Double: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">number</span>
<span class="js-op">&lt;&lt;</span> <span class="js-str">", Count: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">count</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-id">int</span> <span class="js-id">main</span><span class="js-op">()</span> <span class="js-op">{</span>
<span class="js-id">show</span><span class="js-op">(</span><span class="js-num">10</span><span class="js-op">);</span>
<span class="js-id">show</span><span class="js-op">(</span><span class="js-num">5.5</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">Integer</span><span class="js-op">:</span> <span class="js-num">10</span>
<span class="js-id">Double</span><span class="js-op">:</span> <span class="js-num">5.5</span><span class="js-op">,</span> <span class="js-id">Count</span><span class="js-op">:</span> <span class="js-num">1</span></code></pre></div><p>The first call selects the integer overload. The second selects the double overload using its default value for <code>count</code>.</p><h2>6. Function Overloading With const Parameters</h2><p>C++ also considers certain parameter qualifications when determining whether function overloads are different.</p><p>For example, a parameter passed by reference can be overloaded based on whether it refers to a constant or non-constant object.</p><h3>Example: const and Non-const References</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">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-op">&amp;</span><span class="js-id">number</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">"Non-const reference: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">number</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">endl</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-kw">void</span> <span class="js-id">display</span><span class="js-op">(</span><span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-op">&amp;</span><span class="js-id">number</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">"Const reference: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">number</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-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">10</span><span class="js-op">;</span>
<span class="js-kw">const</span> <span class="js-id">int</span> <span class="js-id">fixedValue</span> <span class="js-op">=</span> <span class="js-num">20</span><span class="js-op">;</span>

<span class="js-id">display</span><span class="js-op">(</span><span class="js-id">value</span><span class="js-op">);</span>
<span class="js-id">display</span><span class="js-op">(</span><span class="js-id">fixedValue</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">Non</span><span class="js-op">-</span><span class="js-kw">const</span> <span class="js-id">reference</span><span class="js-op">:</span> <span class="js-num">10</span>
<span class="js-id">Const</span> <span class="js-id">reference</span><span class="js-op">:</span> <span class="js-num">20</span></code></pre></div><p><strong>Explanation:</strong></p><ul><li><p>A non-constant integer variable can bind to the non-const reference overload.</p></li><li><p>A constant integer variable cannot bind to a non-const reference, so the const-reference overload is selected.</p></li></ul><p>This technique is useful when a function should support both modifiable and read-only objects.</p><h2>7. How Does the Compiler Select an Overloaded Function?</h2><p>When an overloaded function is called, the compiler examines the available function candidates and checks how well each parameter list matches the supplied arguments.</p><p>In general, the compiler prefers:</p><ol start="1"><li><p>An exact match.</p></li><li><p>A match requiring a standard promotion.</p></li><li><p>A match requiring a standard conversion.</p></li><li><p>A match requiring a user-defined conversion, where applicable.</p></li></ol><p>If one function is clearly the best match, it is selected.</p><p>If multiple candidates are equally suitable, the call is ambiguous and the compiler reports an error.</p><h3>Example: Exact Match</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">void</span> <span class="js-id">show</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-op">{</span>
<span class="js-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Integer function"</span><span class="js-op">;</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">double</span> <span class="js-id">number</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">"Double function"</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">show</span><span class="js-op">(</span><span class="js-num">10</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">Integer</span> <span class="js-kw">function</span></code></pre></div><p>The argument <code>10</code> is an integer, so the integer overload is an exact match.</p><h2>8. Ambiguous Function Calls in C++</h2><p>Sometimes the compiler cannot decide which overloaded function is the best match.</p><p>This situation is called function overloading ambiguity.</p><h3>Example: Ambiguous Function Call</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">void</span> <span class="js-id">display</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">double</span> <span class="js-id">b</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">"First function"</span><span class="js-op">;</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">double</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-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Second function"</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">display</span><span class="js-op">(</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">10</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>Result:</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">Compilation</span> <span class="js-id">error</span><span class="js-op">:</span> <span class="js-id">ambiguous</span> <span class="js-kw">function</span> <span class="js-id">call</span></code></pre></div><p><strong>Why does this happen?</strong></p><ul><li><p>The first function needs to convert the second integer argument to <code>double</code>.</p></li><li><p>The second function needs to convert the first integer argument to <code>double</code>.</p></li><li><p>Both candidates require one conversion of the same rank.</p></li><li><p>Neither function is a better match.</p></li></ul><h3>How to Fix Ambiguity</h3><p>You can explicitly convert the arguments to the intended types.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-kw">void</span> <span class="js-id">display</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">double</span> <span class="js-id">b</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">"First function"</span><span class="js-op">;</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">double</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-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Second function"</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">display</span><span class="js-op">(</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">10.0</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">First</span> <span class="js-kw">function</span></code></pre></div><p>Now the first overload is an exact match.</p><h2>9. Function Overloading With Different Return Types</h2><p>A common mistake is assuming that two functions can be overloaded only by changing their return types.</p><p>This is not allowed in C++.</p><h3>Incorrect 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">int</span> <span class="js-id">calculate</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-op">{</span>
<span class="js-kw">return</span> <span class="js-id">a</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-id">double</span> <span class="js-id">calculate</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-op">{</span>
<span class="js-kw">return</span> <span class="js-id">a</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p><strong>Result:</strong> Compilation error.</p><p>Both functions have the same name and identical parameter lists. Changing only the return type does not create a valid overload.</p><h3>Correct 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">int</span> <span class="js-id">calculate</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-op">{</span>
<span class="js-kw">return</span> <span class="js-id">a</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-id">double</span> <span class="js-id">calculate</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-op">{</span>
<span class="js-kw">return</span> <span class="js-id">a</span><span class="js-op">;</span>
<span class="js-op">}</span></code></pre></div><p>Here, the parameter types are different, so the functions can be overloaded.</p><h2>10. Practical Example: Area Calculator Using Function Overloading</h2><p>Let's create a program that calculates the area of different shapes using the same function name.</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code>#<span class="js-id">include</span> <span class="js-op">&lt;</span><span class="js-id">iostream</span><span class="js-op">&gt;</span>
<span class="js-id">using</span> <span class="js-id">namespace</span> <span class="js-id">std</span><span class="js-op">;</span>

<span class="js-id">int</span> <span class="js-id">area</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">side</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">return</span> <span class="js-id">side</span> <span class="js-op">*</span> <span class="js-id">side</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-id">int</span> <span class="js-id">area</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">length</span><span class="js-op">,</span> <span class="js-id">int</span> <span class="js-id">width</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">return</span> <span class="js-id">length</span> <span class="js-op">*</span> <span class="js-id">width</span><span class="js-op">;</span>
<span class="js-op">}</span>

<span class="js-id">double</span> <span class="js-id">area</span><span class="js-op">(</span><span class="js-id">double</span> <span class="js-id">radius</span><span class="js-op">)</span> <span class="js-op">{</span>
<span class="js-kw">const</span> <span class="js-id">double</span> <span class="js-id">PI</span> <span class="js-op">=</span> <span class="js-num">3.14159</span><span class="js-op">;</span>
<span class="js-kw">return</span> <span class="js-id">PI</span> <span class="js-op">*</span> <span class="js-id">radius</span> <span class="js-op">*</span> <span class="js-id">radius</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">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Square Area: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">area</span><span class="js-op">(</span><span class="js-num">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-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Rectangle Area: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">area</span><span class="js-op">(</span><span class="js-num">10</span><span class="js-op">,</span> <span class="js-num">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-id">cout</span> <span class="js-op">&lt;&lt;</span> <span class="js-str">"Circle Area: "</span> <span class="js-op">&lt;&lt;</span> <span class="js-id">area</span><span class="js-op">(</span><span class="js-num">3.0</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-id">Square</span> <span class="js-id">Area</span><span class="js-op">:</span> <span class="js-num">25</span>
<span class="js-id">Rectangle</span> <span class="js-id">Area</span><span class="js-op">:</span> <span class="js-num">50</span>
<span class="js-id">Circle</span> <span class="js-id">Area</span><span class="js-op">:</span> <span class="js-num">28.2743</span></code></pre></div><p><strong>Explanation:</strong></p><ul><li><p><code>area(int side)</code> calculates the area of a square.</p></li><li><p><code>area(int length, int width)</code> calculates the area of a rectangle.</p></li><li><p><code>area(double radius)</code> calculates the area of a circle.</p></li><li><p>The compiler selects the appropriate function based on the arguments.</p></li></ul><p>This example shows how function overloading can make related operations easier to organize.</p><h2>11. Function Overloading vs Function Overriding</h2><p>Function overloading and function overriding are different C++ concepts.</p><table><tbody><tr><th>Feature</th><th>Function Overloading</th><th>Function Overriding</th></tr><tr><td>Main purpose</td><td>Same function name with different parameter lists</td><td>A derived class provides a new implementation of a base-class virtual function</td></tr><tr><td>Relationship</td><td>Can occur within the same scope</td><td>Requires inheritance</td></tr><tr><td>Parameters</td><td>Must differ for overloads</td><td>Must match the virtual function signature, subject to C++ rules</td></tr><tr><td>Polymorphism</td><td>Compile-time polymorphism</td><td>Runtime polymorphism when called through virtual dispatch</td></tr><tr><td>Main use</td><td>Handle different input types or counts</td><td>Customize inherited behaviour</td></tr></tbody></table><h3>Example of Function Overriding</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-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">animal</span> <span class="js-op">=</span> <span class="js-kw">new</span> <span class="js-id">Dog</span><span class="js-op">();</span>

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

<span class="js-id">delete</span> <span class="js-id">animal</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><p>The derived class overrides the virtual function from the base class.</p><h2>12. Advantages of Function Overloading in C++</h2><p>Function overloading provides several benefits:</p><ol start="1"><li><p><strong>Code readability:</strong> Use one meaningful name for related operations.</p></li><li><p><strong>Code reusability:</strong> Similar operations can share a consistent interface.</p></li><li><p><strong>Convenience:</strong> Callers do not need to remember multiple function names.</p></li><li><p><strong>Compile-time selection:</strong> The compiler selects the appropriate overload.</p></li><li><p><strong>Maintainability:</strong> Related operations can be organized under one name.</p></li></ol><h2>13. Limitations of Function Overloading</h2><p>Function overloading is useful, but it has some limitations:</p><ul><li><p>Overloaded functions must have distinguishable parameter lists.</p></li><li><p>Changing only the return type is not sufficient.</p></li><li><p>Too many overloads can make code confusing.</p></li><li><p>Implicit conversions can produce ambiguous calls.</p></li><li><p>Default arguments can interact with overloads in unexpected ways.</p></li><li><p>The compiler must be able to determine a valid best match.</p></li></ul><p>Use overloading when the functions perform related operations and share a meaningful interface.</p><h2>14. Common Mistakes in Function Overloading</h2><h3>Mistake 1: Changing Only the Return Type</h3><p>Incorrect:</p><div class="code-card position-relative my-2">
<div class="code-card-actions">
<button type="button" class="btn-code-action copy-code-btn" onclick="copyCode(this)" title="Copy Code">
<i class="far fa-copy"></i>
</button>
<a href="/tools/cpp-compiler" target="_blank" class="btn-code-action run-code-btn" title="Run Online">
<i class="fas fa-play"></i>
</a>
</div>
<pre class="code-box"><code><span class="js-id">int</span> <span class="js-id">calculate</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">double</span> <span class="js-id">calculate</span><span class="js-op">(</span><span class="js-id">int</span> <span class="js-id">a</span><span class="js-op">);</span></code></pre></div><p>The parameter lists are identical, so these cannot form separate overloads.</p><h3>Mistake 2: Using Identical Parameter Lists</h3><p>Two functions cannot have the same name and identical parameter lists within the same scope just because their implementations are different.</p><h3>Mistake 3: Creating Ambiguous Function Calls</h3><p>Overloads that require equally good conversions can cause compilation errors.</p><p>Use explicit argument types or casts when the intended overload is not clear.</p><h3>Mistake 4: Confusing Overloading With Overriding</h3><p>Overloading uses different parameter lists. Overriding replaces inherited virtual-function behaviour in a derived class.</p><h3>Mistake 5: Using Too Many Overloads</h3><p>Creating many overloads for unrelated operations can make the code harder to understand.</p><p>Choose function names and parameter types carefully.</p><h2>15. Best Practices for Function Overloading</h2><p>Follow these practices when designing overloaded functions:</p><ol start="1"><li><p>Use the same function name for operations that perform related tasks.</p></li><li><p>Keep the meaning of each overload consistent.</p></li><li><p>Use clear and distinguishable parameter lists.</p></li><li><p>Avoid overloads that can easily produce ambiguous calls.</p></li><li><p>Be careful when combining default arguments with overloaded functions.</p></li><li><p>Do not rely on return types alone to distinguish functions.</p></li><li><p>Use explicit types when implicit conversions could create confusion.</p></li><li><p>Test each overload with different valid argument combinations.</p></li></ol><h2>16. Frequently Asked Questions (FAQs)</h2><h3>Q1. What is function overloading in C++?</h3><p>Function overloading is a C++ feature that allows multiple functions to have the same name but different parameter lists.</p><h3>Q2. Can two functions have the same name in C++?</h3><p>Yes. They can have the same name if their parameter lists are different and the declarations are otherwise valid.</p><h3>Q3. Can function overloading be achieved by changing only the return type?</h3><p>No. The parameter lists must differ. Changing only the return type does not create a valid overload.</p><h3>Q4. What are the types of function overloading?</h3><p>Common forms include overloading by the number of parameters, parameter types, and order of parameter types.</p><h3>Q5. Is function overloading compile-time polymorphism?</h3><p>Yes. Function overloading is an example of compile-time polymorphism because the compiler selects the appropriate function during compilation.</p><h3>Q6. What is an ambiguous function call?</h3><p>An ambiguous call occurs when the compiler cannot identify one best matching overload among the available candidates.</p><h3>Q7. Can constructors be overloaded in C++?</h3><p>Yes. A class can have multiple constructors with different parameter lists. This is called constructor overloading.</p><h3>Q8. Can member functions be overloaded?</h3><p>Yes. C++ supports overloaded member functions as well as overloaded non-member functions.</p><h3>Q9. What is the difference between function overloading and function overriding?</h3><p>Overloading means using the same function name with different parameter lists. Overriding means providing a derived-class implementation of an inherited virtual function.</p><h3>Q10. Does function overloading improve code reusability?</h3><p>Yes. It allows related operations to share a common function name, making code easier to use and maintain.</p>

Code Example

#include <iostream>
#include <string>

// Overload 1: Integer addition
int calculateSum(int a, int b) {
    return a + b;
}

// Overload 2: Double addition
double calculateSum(double a, double b) {
    return a + b;
}

// Overload 3: String concatenation
std::string calculateSum(const std::string& a, const std::string& b) {
    return a + " " + b;
}

int main() {
    std::cout << "Int Sum: " << calculateSum(10, 20) << "
";
    std::cout << "Double Sum: " << calculateSum(5.25, 3.75) << "
";
    std::cout << "String Concatenation: " << calculateSum(std::string("Hello"), std::string("C++")) << "
";
    return 0;
}

Interview Question & Tips

Q: Can two functions be overloaded if only their return types differ?
A: No. Function call statements (e.g. `calculate();`) do not specify expected return types, making ambiguous calls impossible to resolve.

Q: What is name mangling in C++?
A: Name mangling is the compiler technique of decorating function names with type codes for their arguments so the linker can differentiate overloaded functions with identical source names.

Best Practices

1. Do not overload functions with ambiguous implicit conversions (e.g. `f(int)` and `f(long)` when called with `short`).
2. Keep the semantic purpose identical across all overloads of a function name.
3. Use templates instead of writing dozens of identical overloads for different types.
Academic Standards & Verified Citations

This study reference for Function Overloading in C++: Multiple Signatures for One Function Name is curated and verified against recognized curriculum benchmarks, peer-reviewed textbooks, and official technical documentation:

C++ Programming