Function overloading in C++ - Mini Project: Build & Apply

Function overloading

📖 Scenario: You are creating a simple calculator program that can add numbers. Sometimes you want to add two numbers, and other times you want to add three numbers.

🎯 Goal: Build a program that uses function overloading to add two or three integers using the same function name add.

📋 What You'll Learn

Create two functions named add: one that takes two integers and one that takes three integers.

Each add function should return the sum of its parameters.

Call both add functions with example values and print the results.

💡 Why This Matters

🌍 Real World

Function overloading helps create cleaner code when you want to perform similar actions with different inputs, like calculators or data processors.

💼 Career

Understanding function overloading is important for writing flexible and readable code in C++ software development jobs.

1

Create the first add function

Write a function called add that takes two int parameters named a and b and returns their sum.

C++

#include 

using namespace std;

// Write the add function that takes two int parameters

int main() {
    
    return 0;
}

Hint

Define a function named add with two int parameters and return their sum using return a + b;.

2

Create the second add function

Add another function called add that takes three int parameters named a, b, and c and returns their sum.

C++

#include 

using namespace std;

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

// Write the add function that takes three int parameters

int main() {
    
    return 0;
}

Hint

Define a second add function with three int parameters and return their sum.

3

Call both add functions

Inside main, call add(5, 7) and store the result in an int variable named sum_two. Then call add(1, 2, 3) and store the result in an int variable named sum_three.

C++

#include 

using namespace std;

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

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

int main() {
    // Call add(5, 7) and store in sum_two
    // Call add(1, 2, 3) and store in sum_three
    
    return 0;
}

Hint

Use the add function with two and three arguments and save the results in sum_two and sum_three.

4

Print the results

Add two cout statements to print sum_two and sum_three on separate lines with the exact text: Sum of two numbers: and Sum of three numbers: respectively.

C++

#include 

using namespace std;

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

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

int main() {
    int sum_two = add(5, 7);
    int sum_three = add(1, 2, 3);
    
    // Print sum_two with text "Sum of two numbers: "
    // Print sum_three with text "Sum of three numbers: "
    
    return 0;
}

Hint

Use cout to print the text and the variables, ending each line with endl.

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