Overriding Member Function in C++

In Object-oriented programming, Inheritance is one of the most powerful concepts. It enables a class to inherit characteristics and behaviors from another class. Overriding is a technique used in C++ programming to modify the behavior of an inherited member function in a derived class. In this article, we will see the concept of Overriding Member functions in C++ in detail.

What is Overriding Member Function?

In C++, when a Derived class inherits a Member function from its Base class, it can redefine the behavior of that function in the Derived class. This process of redefining a Base class Member Function in a Derived class is called "Overriding" and the redefined function is referred to as an "Overridden Member Function".

In other words, when a Derived class defines a Member Function with the same name and signature as a Member Function in its Base class, the Derived class's function will Override the Base class function.

How to Override a Member Function in C++?

To Override a Member Function in C++, we need to follow the steps given below:

Step 1: Define a Base Class with a Virtual Function:

A Virtual Function is a type of member function declared with the keyword "Virtual" in the base class. This indicates that the function can be Overridden in the derived class. The syntax for declaring a Virtual Function is as follows:

C++ code:

class Base {
public:
    virtual void myFunction() {
        // Base class implementation
    }
};

Step 2: Define a Derived Class that Overrides the Virtual Function:

To Override a Virtual Function, we need to define a derived class that inherits from the base class and provides a new implementation of the Virtual Function. The syntax for defining a derived class that overrides the Virtual Function is as follows:

C++ Code:

class Derived : public Base {
public:
    void myFunction() override {
        // Derived class implementation
    }
};

Step 3: Create Objects of the Derived Class and Call the Virtual Function:

We can create objects of the derived class and call the Virtual Function using a Pointer to the base class. The syntax for creating objects of the derived class and calling the Virtual Function is as follows:

C++ Code:

Base* basePtr = new Derived();
basePtr->myFunction();

When we call the Virtual Function using a Pointer to the base class, the implementation of the Virtual Function in the derived class will be called.

Example:

Let's look at an example that demonstrates the concept of Overriding Member Functions in C++. In the above example, we have a base class or parent class called, which has a virtual function. We also have two derived classes called Circle and Square, which override the draw() function to provide their own implementation.

C++ Code:

#include <iostream>
class Shape {
public:
    virtual void draw() {
        std::cout << "Drawing a shape" << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a square" << std::endl;
    }
};

int main() {
    Shape* shapePtr = new Circle();
    shapePtr->draw();

    shapePtr = new Square();
    shapePtr->draw();

    return 0;
}

Output:

Drawing a circle
Drawing a square

In this example, we create objects of the Circle and Square classes and call the draw() function using a pointer to the base class Shape. Since the draw() function is Virtual, the implementation in the derived classes is called, and we get the output "Drawing a circle" and "Drawing a square".

Advantages of Overriding Member Function:

Polymorphism:

One of the major advantages of overriding is that it enables Polymorphism. Polymorphism allows a derived class to have multiple behaviors depending on the context in which it is used.

Code Reusability:

Overriding allows the reuse of code from the base class while allowing the derived class to modify the behavior of the base class's member functions.

Modularity:

Overriding makes it easier to maintain code because changes made in the derived class do not affect the base class.

Rules for Overriding Member Functions:

The Overridden Function in the derived class must have the same name and arguments as the base class function.
The Overridden Function must have the same return type as the base class function or a covariant return type.
The access level of the Overridden Function in the derived class cannot be more restrictive than the access level of the base class function.
The Virtual keyword must be used in the base class function declaration.
The function in the base class must be declared with the same access level or higher than the derived class.

Next TopicPassword Validation in C++

← prev next →