Function Overriding in C++ [Function Overloading vs Overriding with Examples]

Function overloading and overriding in C++ are powerful ways to make code flexible and specific. Imagine Ford, the car company, which produces various vehicles. Each vehicle inherits basic features like the brand name and type, but each model can also have unique features. A sports car, for instance, is still a car but might have different handling or engine specifications.

In C++ library, function overloading allows you to define multiple versions of a function, each with different parameters. This means you can use the same function name but adapt it for different situations. Function overriding, on the other hand, lets a derived class (like the sports car) replace a function inherited from a parent class, allowing each version to fit specific needs.

Studies show that around 75% of C++ projects rely on these methods to keep code clear and easy to work with. In this article, we’ll go over the basics of function overloading and overriding in C++ with examples to help you understand clearly.

What is Function Overloading in C++?

Function overloading in C++ is a feature of object-oriented programming. It allows multiple functions to share the same name within the same scope but differ in the number or type of parameters. This feature enables you to define different versions of a function that handle varying inputs without needing separate function names. When the program runs, the compiler selects the correct version based on the provided arguments. This process is known as compile-time polymorphism. Function overloading is particularly useful for performing similar operations on different types of data or varying numbers of arguments.

Key Aspects of Function Overloading in C++

1. Parameter Type Variation
Function overloading can be achieved by changing the data types of parameters. For instance, you can create two versions of the same function with different parameter types and allow a single function name to handle multiple data types.
cpp

void display(int number) {
    cout << "Integer: " << number << endl;
}

void display(double number) {
    cout << "Double: " << number << endl;
}

In this example, the display() function is overloaded. One version accepts an int, while the other accepts a double. This lets you use display() for both integer and floating-point numbers without creating two separate function names.

2. Parameter Count Variation
Another way to overload functions is by changing the number of parameters they accept. For example, you could design a function to perform a task differently based on whether it receives one, two, or more arguments.
cpp

int calculateArea(int side) {
    return side * side; // Area of a square
}

int calculateArea(int length, int width) {
    return length * width; // Area of a rectangle
}

Here, calculateArea() is overloaded. With one parameter, it calculates the area of a square. With two parameters, it computes the area of a rectangle. This flexibility makes the code more readable and easier to use.

Why Use Function Overloading?

• Improves Readability:

  Overloading makes your code easier to understand. Using the same name for similar functions makes it clear that each version relates to the same concept but with different details.

• Reduces Code Redundancy:

  Overloading helps avoid redundant code by eliminating the need for multiple distinct function names. This reduces clutter and helps keep your codebase clean.

• Enables Compile-Time Polymorphism:

  Overloading allows the program to determine the correct function version at compile-time based on arguments. This ensures the program runs more efficiently and avoids errors.

Become a Full-Stack Developer. Enroll in upGrad’s courses today!

Practical Example: Parameter Type and Count Overloading

Here’s an example combining both parameter type and count variations for an add() function. Each version is suited to different input combinations:

cpp

// Adding two integers
int add(int a, int b) {
    return a + b;
}

// Adding three integers
int add(int a, int b, int c) {
    return a + b + c;
}

// Adding two floating-point numbers
double add(double a, double b) {
    return a + b;
}

In this setup:

• add(int, int) adds two integers.
• add(int, int, int) handles three integers.
• add(double, double) manages two floating-point numbers.

When you call add(), the compiler will automatically choose the correct version. It does this by matching the argument types and counts with the appropriate function definition.

What is Function Overriding in C++?

In C++, function overriding lets a derived class redefine a function inherited from its base class. Unlike function overloading, which involves functions with the same name but different parameters, function overriding requires an exact match in the function name, parameters, and return type between the base and derived class functions. This feature is essential for runtime polymorphism, as it allows the program to determine which function to call based on the object type at runtime rather than compile-time. Overriding a function provides flexibility, which enables derived classes to give specialized behavior to an inherited function.

Key Aspects of Function Overriding in C++

1. Basic Function Overriding
In basic function overriding, the derived class redefines a method inherited from the base class without using any special keywords. This redefined function in the derived class replaces the base class’s function when accessed through a derived class object. However, without the virtual keyword, there’s no polymorphic behavior.
cpp

class Animal {
public:
    void speak() {
        cout << "Animal speaks." << endl;
    }
};

class Dog : public Animal {
public:
    void speak() {  // Overrides speak() in Animal
        cout << "Dog barks." << endl;
    }
};

Here, speak() in the Dog class overrides speak() in Animal. If we create a Dog object and call speak(), the output will be "Dog barks." This demonstrates basic function overriding.

2. Virtual Function Overriding
To achieve true polymorphism, we use virtual functions. Declaring a function as virtual in the base class allows the derived class to override it. When accessed through a base class pointer or reference, the program calls the overridden function in the derived class, enabling dynamic binding.
cpp

class Shape {
public:
    virtual void draw() {  // Virtual function in base class
        cout << "Drawing shape." << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {  // Overrides draw() in Shape
        cout << "Drawing circle." << endl;
    }
};

In this example, draw() in Shape is a virtual function, allowing Circle to override it. If we create a Shape pointer that points to a Circle object and call draw(), the Circle’s draw() function will execute, showcasing polymorphic behavior.

3. Non-Virtual Function Overriding
Function overriding without virtual limits polymorphism. Overriding a non-virtual function in the derived class simply replaces the base class’s version, but only for derived class objects. This approach is uncommon in OOP as it lacks the flexibility of dynamic binding.
cpp

class Vehicle {
public:
    void info() {  // Non-virtual function
        cout << "This is a vehicle." << endl;
    }
};

class Car : public Vehicle {
public:
    void info() {  // Overrides info() in Vehicle
        cout << "This is a car." << endl;
    }
};

Here, info() in Vehicle is overridden in Car, but without the virtual keyword. Calling info() on a Vehicle pointer to a Car object would execute Vehicle’s info() rather than Car’s, showing no polymorphism.

Why Use Function Overriding?

• Enhanced Flexibility:

  Function overriding lets derived classes tailor inherited functionality, making classes more adaptable and suitable for specific tasks.

• Runtime Polymorphism:

  Virtual function overriding supports runtime polymorphism, allowing C++ to dynamically bind function calls based on the actual object type. This is essential for creating flexible, extensible code.

• Code Reusability:

  By allowing derived classes to build on and modify base class functions, overriding encourages reusing and adapting code rather than duplicating it.

Example Code Demonstrating Polymorphism through Virtual Function Overriding

This example uses a base Animal class with a virtual function sound() and derived classes Dog and Cat, each with its own version of sound().

cpp

class Animal {
public:
    virtual void sound() {  // Virtual function
        cout << "Some generic animal sound." << endl;
    }
};

class Dog : public Animal {
public:
    void sound() override {  // Overrides sound()
        cout << "Woof Woof." << endl;
    }
};

class Cat : public Animal {
public:
    void sound() override {  // Overrides sound()
        cout << "Meow." << endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->sound();  // Outputs: Woof Woof
    animal2->sound();  // Outputs: Meow

    delete animal1;
    delete animal2;
    return 0;
}

In this example:

• The sound() function is virtual in Animal.
• Dog and Cat classes override sound() with their implementations.
• The program uses a base class pointer to call the correct function at runtime, demonstrating polymorphic behavior.

Function Overloading vs. Function Overriding: Key Differences

In C++, function overloading and function overriding provide distinct ways to handle functions, each with its own purpose and application.

Function overloading happens at compile-time and allows multiple functions with the same name but different parameters (varying by type or count) to exist in a class. This improves readability and makes it easy to use one function name to handle different types of inputs. Overloading doesn’t rely on inheritance, so it can be used within a single class.

Function overriding, in contrast, takes place at runtime and requires inheritance. It lets a derived class define its own version of a function that’s already in the base class, supporting polymorphism. This means the function used depends on the object’s actual type when called.

Key distinctions between function overloading and overriding include:

1. Inheritance Requirement
   • Overloading: No inheritance is needed and can be done within one class.
   • Overriding: Requires inheritance, with the derived class function replacing the base class function.
2. Timing
   • Overloading: Happens at compile-time, with the compiler choosing the function based on parameter types and counts.
   • Overriding: Occurs at runtime, allowing the program to select the derived class function when accessed through a base class reference.
3. Function Signature
   • Overloading: Requires different signatures—either the number or type of parameters changes.
   • Overriding: Requires identical function signatures in the base and derived classes.
4. Binding and Scope
   • Overloading: Uses static binding, determined by the compiler.
   • Overriding: Uses dynamic binding, where the function called is based on the object’s type at runtime.
5. Purpose
   • Overloading: Provides options to perform similar tasks on different data.
   • Overriding: Allows the derived class to modify or add to the base class function.

Summary Table

Examples of Function Overloading in C++

Function overloading allows developers to define multiple functions with the same name but different parameters. This makes code more flexible and reusable, as it enables performing similar tasks on different data types or structures. Below, we'll explore practical examples of function overloading to calculate areas for different shapes.

• Example 1: Function Overloading for display() Function

This example demonstrates overloading the display() function to output different data types: an integer and a string. By overloading, we can use the same function name display() to print either an integer or a string, depending on the input parameter.

Code Example

cpp

#include <iostream>
using namespace std;

// Function to display an integer
void display(int num) {
    cout << "Integer: " << num << endl;
}

// Overloaded function to display a string
void display(string text) {
    cout << "String: " << text << endl;
}

int main() {
    display(25);         // Calls the integer version of display
    display("Hello!");   // Calls the string version of display

    return 0;
}

Output

makefile

Integer: 25
String: Hello!

Explanation

• The display(int num) function is designed to print an integer value. When we pass an integer to display(), this version is called.
• The display(string text) function is designed to print a string. When we pass a string to display(), this version is called.
• This way, we only need to remember one function name, display(), which can handle different types of input based on the data type passed. The compiler automatically selects the correct version of display() based on whether we pass an integer or a string.

• Example 2: Function Overloading for multiply() Function

This example shows the overloading of the multiply() function to perform multiplication on different data types: two integers, and a double with an integer.

Code Example

cpp

#include <iostream>
using namespace std;

// Function to multiply two integers
int multiply(int a, int b) {
    return a * b;
}

// Overloaded function to multiply a double and an integer
double multiply(double a, int b) {
    return a * b;
}

int main() {
    int intResult = multiply(4, 5);          // Calls the integer version of multiply
    double doubleResult = multiply(3.5, 2);  // Calls the double version of multiply

    cout << "Multiplication of integers: " << intResult << endl;
    cout << "Multiplication of double and integer: " << doubleResult << endl;

    return 0;
}

Output

php

Multiplication of integers: 20
Multiplication of double and integer: 7

Explanation

• multiply(int a, int b) is defined to take two integer values, multiply them, and return the result as an integer.
• multiply(double a, int b) is defined to take a double and an integer, multiply them, and return the result as a double.
• When multiply(4, 5) is called with two integers, it invokes the first function, which returns 20.
• When multiply(3.5, 2) is called with a double and an integer, it invokes the second function, which returns 7.0.

This example highlights how we can use the same function name, multiply(), to perform different operations based on input types, streamlining the code while keeping it versatile.

upGrad’s Exclusive Software and Tech Webinar for you –

SAAS Business – What is So Different?

Examples of Function Overriding in C++

In function overriding, a child class changes the behavior of a function it inherits from a parent class. This lets the child class define its own version of the function while keeping the original function in the parent class. Let’s use an easy example to understand this.

Imagine the RBI (Reserve Bank of India) as a parent class. It sets up basic banking rules like loan_policy() and insurance_policy(). Now, banks like SBI and HDFC inherit from RBI, but each bank has its own loan policy. With function overriding, SBI and HDFC can each create their specific loan policy, even though they follow RBI’s main rules.

• Example 1: RBI and Banks with Overriding Services

Here’s an example in C++ to show how RBI as the parent class has a loan_policy() function, which is then overridden by SBI and HDFC.

cpp

#include <iostream>
using namespace std;

// Parent class representing RBI
class RBI {
public:
    // RBI's loan policy
    virtual void loan_policy() {
        cout << "RBI Loan Policy: Standard interest rate.\n";
    }
};

// Child class representing SBI
class SBI : public RBI {
public:
    // SBI's loan policy
    void loan_policy() override {
        cout << "SBI Loan Policy: Special rate for SBI customers.\n";
    }
};

// Child class representing HDFC
class HDFC : public RBI {
public:
    // HDFC's loan policy
    void loan_policy() override {
        cout << "HDFC Loan Policy: Premium rate for HDFC customers.\n";
    }
};

int main() {
    RBI* rbi_ptr;
    SBI sbi;
    HDFC hdfc;

    // Using RBI pointer to access overridden functions
    rbi_ptr = &sbi;
    rbi_ptr->loan_policy(); // Calls SBI's loan_policy

    rbi_ptr = &hdfc;
    rbi_ptr->loan_policy(); // Calls HDFC's loan_policy

    return 0;
}

Output

rust

SBI Loan Policy: Special rate for SBI customers.
HDFC Loan Policy: Premium rate for HDFC customers.

Explanation

• RBI sets a general loan policy.
• SBI and HDFC each override this with their own loan policies.
• Using an RBI pointer, we can access the specific loan policies of each bank, thanks to polymorphism.
• Example 2: Overriding with an Analogy - Constitutions

Let’s consider the Constitution as the parent class. Different countries take inspiration from other constitutions but customize them to fit their own needs. Here, we’ll create a base class Constitution with a general law_system() method. Then, USA_Constitution and UK_Constitution override this method with their specific systems.

cpp

#include <iostream>
using namespace std;

// Parent class representing general Constitution
class Constitution {
public:
    virtual void law_system() {
        cout << "General Law System: Basic legal framework.\n";
    }
};

// Child class representing USA's legal system
class USA_Constitution : public Constitution {
public:
    void law_system() override {
        cout << "USA Legal System: Presidential system with checks and balances.\n";
    }
};

// Child class representing UK’s legal system
class UK_Constitution : public Constitution {
public:
    void law_system() override {
        cout << "UK Legal System: Parliamentary system with monarchy.\n";
    }
};

int main() {
    Constitution* const_ptr;
    USA_Constitution usa;
    UK_Constitution uk;

    const_ptr = &usa;
    const_ptr->law_system(); // Calls USA's law_system

    const_ptr = &uk;
    const_ptr->law_system(); // Calls UK's law_system

    return 0;
}

Output

sql

USA Legal System: Presidential system with checks and balances.
UK Legal System: Parliamentary system with monarchy.

Explanation

• Constitution provides a general law_system().
• USA_Constitution and UK_Constitution override this with their own systems.
• The base pointer Constitution* lets us access the specific legal system for each country.

Common Mistakes in Function Overloading and Overriding in C++

When working with function overloading and overriding in C++, some mistakes are easy to make. Here’s a guide to avoid the most common ones, with examples for clarity.

1. Forgetting the virtual Keyword in the Base Class

• Problem: If the base class function isn’t marked as virtual, overriding won’t work as expected. The base class function will be called instead of the derived one, especially when using a base class pointer.

Example:
cpp

class Base {
    // Missing virtual keyword
    void display() { std::cout << "Base class\n"; }
};

class Derived : public Base {
    void display() { std::cout << "Derived class\n"; }
};

int main() {
    Base* obj = new Derived();
    obj->display(); // Outputs: "Base class" instead of "Derived class"
    return 0;
}

Fix: Add virtual to the base class function to enable overriding.

2. Overloading with Identical Parameter Types

• Problem: Attempting to overload functions with the same parameters doesn’t work. The compiler won’t know which function to call, resulting in a compilation error.

Example:
cpp

class Test {
    void calculate(int x) { /*...*/ }
    void calculate(int y) { /*...*/ } // Error: Same parameter type
};

Solution: Ensure each overloaded function has a unique signature by changing parameter types or the number of parameters.

3. Incorrect Use of Scope Resolution in Overriding

• Problem: Using the scope resolution operator :: when calling a function directly on an object will call the base class function, not the overridden one. This can be confusing if you meant to use the derived class version.

Example:
cpp

class Animal {
public:
    virtual void sound() { std::cout << "Some animal sound\n"; }
};

class Dog : public Animal {
public:
    void sound() override { std::cout << "Bark\n"; }
};
int main() {
    Dog dog;
    dog.Animal::sound(); // Calls Animal's sound() instead of Dog's
    return 0;
}

Tip: Use the scope resolution operator with the base class only if you want to explicitly call the base function.

Quick Reminders:

• Add virtual to any base function you plan to override in a derived class.
• Make sure overloaded functions have unique parameter signatures.
• Avoid unnecessary scope resolution to prevent accidentally calling the base class function.

Learn C++ Programming

If you’re curious about coding or want to strengthen your programming skills, our C++ tutorials are designed just for you. These tutorials break down C++ in simple, clear steps, helping you learn at your own pace with real examples and practical exercises.

What You’ll Get:

• 77 Short Lessons: Learn C++ basics and advanced topics in easy-to-manage chunks.
• 15 Hours of Learning: Perfect for fitting around your schedule.
• Practical Coding Examples: Understand concepts by actually using them.
• Pro Tips from Experts: Discover tips to write cleaner, more efficient code.
• Build Real Skills: Get confident with C++ and be ready for real-world projects.

Start your C++ journey with upGrad’s tutorials—your first step into programming awaits!

Advance your tech career with our Popular Software Engineering Courses, featuring practical projects and industry-relevant skills to make you job-ready.

Stay ahead in the tech world by learning essential software development skills, including cloud computing, API integration, and version control systems.

Jumpstart your coding journey with our Free Software Development Courses, covering core programming concepts and practical skills at no cost.