Function overloading in C++ - Step-by-Step Execution

Concept Flow - Function overloading

Define multiple functions with same name

↓

Call function with arguments

↓

Compiler checks argument types

↓

Select matching function

↓

Execute selected function

↓

Return result

Function overloading lets you create several functions with the same name but different argument types or counts. When you call the function, the compiler picks the right one based on the arguments.

Execution Sample

C++

int add(int a, int b) {
    return a + b;
}

float add(float a, float b) {
    return a + b;
}

int main() {
    int x = add(2, 3);
    float y = add(2.5f, 3.5f);
    return 0;
}

This code shows two 'add' functions: one for integers and one for floats. The compiler chooses which to run based on the argument types.

Execution Table

Step	Function Call	Argument Types	Function Selected	Return Value
1	add(2, 3)	int, int	int add(int a, int b)	5
2	add(2.5f, 3.5f)	float, float	float add(float a, float b)	6.0
3	End of main	-	-	-

💡 Program ends after both function calls return their results.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
x	undefined	5	5	5
y	undefined	undefined	6.0	6.0

Key Moments - 2 Insights

Why does the compiler pick different functions for add(2, 3) and add(2.5f, 3.5f)?

The compiler looks at the argument types in each call (int vs float) and matches them to the function with the same parameter types, as shown in execution_table steps 1 and 2.

What happens if I call add(2, 3.5f)?

The compiler tries to find the best match or convert types. If no exact match exists, it may convert one argument or give an error. This is not shown in the table but is important to know.

Visual Quiz - 3 Questions

Look at the execution table, what is the return value of add(2, 3) at step 1?

A 2

B 6

C 5

D Error

💡 Hint

Check the 'Return Value' column in execution_table row for step 1.

At which step does the function with float parameters get called?

A Step 2

B Step 1

C Step 3

D No float function called

💡 Hint

Look at the 'Function Selected' column in execution_table for step 2.

If you call add(2, 3.5f), what is likely to happen?

A Calls int add(int, int)

B Compiler error or implicit conversion

C Calls float add(float, float)

D Calls both functions

💡 Hint

Refer to key_moments explanation about mixed argument types.

Concept Snapshot

Function overloading allows multiple functions with the same name but different parameter types or counts.
The compiler chooses the correct function based on argument types at the call.
Syntax: Define functions with same name but different parameters.
Useful for similar operations on different data types.
If no exact match, compiler tries conversions or errors.
Overloading improves code readability and reuse.

Full Transcript

Function overloading in C++ means you can write several functions with the same name but different types or numbers of parameters. When you call the function, the compiler looks at the arguments you give and picks the matching function to run. For example, if you have add(int, int) and add(float, float), calling add(2, 3) uses the int version and add(2.5f, 3.5f) uses the float version. This helps write cleaner code that works with different data types. If you mix types like add(2, 3.5f), the compiler tries to find the best match or may give an error. The execution table shows each step: which function is called and what it returns. Variables x and y store the results after each call. Remember, the compiler decides which function to run by matching argument types.

Practice

1.

What is the main purpose of function overloading in C++?

easy

A. To create functions that return different data types

B. To allow multiple functions with the same name but different parameters

C. To define functions inside other functions

D. To overload operators like + and -

Solution

1. Step 1: Understand function overloading concept

   Function overloading means having multiple functions with the same name but different parameter lists.

2. Step 2: Compare options with definition

   Only To allow multiple functions with the same name but different parameters correctly describes this concept. Other options describe different features.

3. Final Answer:

   To allow multiple functions with the same name but different parameters -> Option B

4. Quick Check:

   Function overloading = same name, different parameters [OK]

Hint: Remember: same name, different parameters means overloading [OK]

Common Mistakes:

• Confusing overloading with operator overloading
• Thinking overloading changes return type only
• Mixing up function overloading with function overriding

2.

Which of the following is a correct function overloading declaration in C++?

void print(int x);
void print(double x);
void print(int x, int y);
void print(int x);

easy

A. The last declaration causes a compilation error

B. The third declaration is invalid

C. The second declaration is invalid

D. All declarations are correct

Solution

1. Step 1: Check for duplicate function signatures

   The first and last declarations have the same signature: void print(int x);.

2. Step 2: Understand function overloading rules

   Multiple declarations with identical signatures are allowed only if they are declarations, but defining the same function multiple times causes compilation error.

3. Final Answer:

   The last declaration causes a compilation error -> Option A

4. Quick Check:

   Duplicate function definitions cause errors [OK]

Hint: Duplicate declarations allowed, duplicate definitions cause errors [OK]

Common Mistakes:

• Thinking return type differentiates overloaded functions
• Thinking duplicate declarations cause compilation errors
• Assuming default parameters allow identical signatures

3.

What will be the output of the following code?

void display(int x) { std::cout << "Int: " << x << std::endl; }
void display(double x) { std::cout << "Double: " << x << std::endl; }

int main() {
  display(5);
  display(5.5);
  return 0;
}

medium

A. Compilation error due to ambiguous call

B. Double: 5Double: 5.5

C. Int: 5Int: 5

D. Int: 5Double: 5.5

Solution

1. Step 1: Identify which function matches each call

   Call display(5) matches display(int). Call display(5.5) matches display(double).

2. Step 2: Understand output from each function

   First call prints "Int: 5", second prints "Double: 5.5".

3. Final Answer:

   Int: 5
   Double: 5.5 -> Option D

4. Quick Check:

   Matching parameter type calls correct function [OK]

Hint: Match argument type to function parameter type [OK]

Common Mistakes:

• Assuming implicit conversion causes ambiguity
• Confusing int and double overloads
• Expecting compilation error for valid overloads

4.

Find the error in the following code snippet:

void sum(int a, int b) { std::cout << a + b << std::endl; }
void sum(int a, int b, int c) { std::cout << a + b + c << std::endl; }

int main() {
  sum(5, 10);
  sum(5, 10, 15);
  sum(5, 10, 15, 20);
  return 0;
}

medium

A. Third call to sum causes compilation error

B. No error, code runs fine

C. First sum function is missing return type

D. Second sum function has wrong parameter types

Solution

1. Step 1: Check function declarations

   Two sum functions exist: one with 2 int parameters, one with 3 int parameters.

2. Step 2: Analyze function calls

   Calls with 2 and 3 arguments match existing functions. Call with 4 arguments has no matching function, causing error.

3. Final Answer:

   Third call to sum causes compilation error -> Option A

4. Quick Check:

   Function call must match declared overloads [OK]

Hint: Check number of arguments matches function parameters [OK]

Common Mistakes:

• Assuming extra arguments are ignored
• Thinking default parameters exist without declaration
• Ignoring compilation errors on unmatched calls

5.

Consider the following overloaded functions:

int multiply(int a, int b) { return a * b; }
double multiply(double a, double b) { return a * b; }
int multiply(int a, int b, int c = 1) { return a * b * c; }

What will be the output of std::cout << multiply(2, 3) << std::endl;?

hard

A. 6 (from the first function)

B. 6 (from the third function with default parameter)

C. Compilation error due to ambiguous call

D. 6.0 (from the second function)

Solution

1. Step 1: Identify overloaded functions with matching signatures

   Two functions can match call multiply(2, 3): int multiply(int, int) and int multiply(int, int, int=1) because default parameter allows 2 arguments.

2. Step 2: Understand ambiguity in overload resolution

   Compiler cannot decide which function to call because both are equally good matches, causing ambiguity error.

3. Final Answer:

   Compilation error due to ambiguous call -> Option C

4. Quick Check:

   Default parameters can cause ambiguous overloads [OK]

Hint: Default parameters can create ambiguous overloads [OK]

Common Mistakes:

• Ignoring ambiguity caused by default arguments
• Assuming first declared function is chosen
• Confusing return type with overload resolution