Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/function-overriding-in-cpp/ below:

Function Overriding in C++ - GeeksforGeeks

Last Updated : 11 Aug, 2025

A function is a block of code that performs a specific task. It takes input, processes it, and returns an output. Function Overriding in C++ is a type of polymorphism where a derived class redefines a function from its base class using the same name, return type, and parameters (i.e., the same function signature).

• The base class function must be virtual.
• The derived class must use the same signature.
• It's a form of runtime polymorphism (dynamic binding).

• If you call the function using a base class object, the base class version is executed.
• If you call it using a derived class object, the derived class version is executed.

class Animal {
public:
    virtual void sound() {
        cout << "Animal makes a sound\n";
    }
};

class Dog : public Animal {
public:
    void sound() override {  // Correct override
        cout << "Dog barks\n";
    }
};

To avoid mistakes when overriding functions, C++ introduced the override keyword.

• Ensures you're actually overriding a virtual function.
• If the signature doesn't match any base class function, the compiler gives an error.

class Dog : public Animal {
public:
    void Sound() override {  // Error: No matching function in base class
        cout << "Dog barks\n";
    }
};

Without override, this would compile but not override the base function - leading to unexpected behviour.

India adopted principles from other countries and redefined them in its own context—just like overriding base behavior with derived custom logic.

In C++, function overriding with pointers is a common use case of polymorphism. When a base class has a virtual function, and a derived class overrides it, the function call is resolved at runtime based on the type of the object being pointed to, not the type of the pointer. Example:

#include <iostream>
using namespace std;
class Base{
    public:
        virtual void display(){
            cout<<"Display from Base class"<<endl;
        }
};
class Derived: public Base{
    public:
        void display() override{
            cout<<"Display from derived class"<<endl;
        }
};
int main() {
    Base * basePtr;
    Derived derivedObj;
    basePtr=&derivedObj;
    basePtr->display();
    return 0;
}

Display from derived class

If the base function is not virtual, the derived function with the same name just hides the base function. This is called function hiding, not overriding.

#include<iostream>
using namespace std;

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

class Dog : public Animal {
public:
    void sound() {  // Not overriding, just hiding
        cout << "Dog barks\n";
    }
};

int main() {
    Animal* a = new Dog();
    a->sound();  // Output: Animal sound
}

1. Dynamic behavior at runtime.
2. Promotes code reuse through inheritance.
3. Changes in base class can affect derived classes easily.
4. Enables design patterns like Strategy, Command, etc.
5. Encourages loose coupling by coding to base class interfaces.

1. Slightly slower than normal function calls due to virtual table lookup.
2. Adds memory overhead (vtable, vptr).
3. Complexity increases in large inheritance hierarchies.
4. Mistakes in overriding may cause bugs if signatures don't match.
5. Requires careful design to avoid maintenance issues.

The final keyword is used to prevent further overriding or inheritance of:

1. Virtual functions — to stop them from being overridden in derived classes.
2. Classes — to stop them from being inherited.

Used to stop a derived class from overriding a virtual function.

class Base {
public:
    virtual void show() final {  // Cannot be overridden
        cout << "Base show\n";
    }
};

class Derived : public Base {
public:
    void show() override {       // Error: cannot override final function
        cout << "Derived show\n";
    }
};

Used to stop a class from being inherited.

class FinalClass final {
public:
    void display() {
        cout << "This is a final class\n";
    }
};

class SubClass : public FinalClass {  // Error: cannot inherit from final class
};

• Safety: Prevent accidental overriding or inheritance.
• Optimization: Helps compiler make better decisions for inlining and performance.
• Design clarity: Clearly communicates that "this method/class should not be changed".

• Function Overriding allows redefining inherited behavior to suit derived class needs.
• The base function should be marked as virtual, and the derived function should ideally use override.
• It enables runtime polymorphism, which is useful in building flexible, reusable, and loosely coupled code.
• Avoid function hiding by always matching the exact signature and using override.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4