How To Call A Virtual Function From A Derived Class In C++

In this guide, we will explore the process of invoking a virtual method from a subclass in C++ along with its benefits.

Introduction:

Polymorphism stands out as a fundamental aspect of object-oriented programming, particularly in C++. Essentially, it pertains to the existence of multiple forms. These various forms materialize when a subclass offers an implementation for a function that has already been outlined in its superclass. Absence of this principle would jeopardize the code's adaptability and reusability as it empowers developers to craft generic codes that can be applied to diverse entities.

Problem Statement:

To this extent, when working with polymorphism in C++, you may encounter situations where it is necessary to invoke a virtual function from a subclass. This scenario commonly occurs when adjustments need to be made to a method inherited from a base class to better suit the current scenario. However, ensuring the correct execution of overridden virtual functions requires a clear understanding of how inheritance and dynamic dispatch function in conjunction with virtual functions in C++.

Virtual Function: In C++, a virtual function refers to any member function (within classes), which can be redefined in its derived versions thus enabling different implementations based on the actual type of object used for calling them. It is important because without such feature it would not be possible to achieve polymorphism whereby single interface can represent multiple underlying behaviors.

• ✅ Virtual functions make sure that a right function is invoked for an object, regardless of how the objects are referred to using pointer.
• ✅ The main use of them is to implement runtime polymorphism.
• ✅ In a base class, functions are declared with a virtual keyword.
• ✅ The resolving of a function call is done at runtime.

Solution:

Begin by establishing a Base Class: Commence the process by defining a foundational class that encompasses the virtual function intended to be redefined in the derived class. For instance:

class Base {
public:
    virtual void virtualFunction() {
        std::cout << "Base class virtual function\n";
    }
};
Derive a Class:Next, derive a class from the base class and override the virtual function. This is where you provide the specialized implementation for the virtual function in the derived class:
class Derived : public Base {
public:
    void virtualFunction() override {
        std::cout << "Derived class virtual function\n";
    }
};

Notice the utilization of the override keyword in the subclass. This specific keyword serves as an indication to the compiler that the function is meant to replace a virtual function in the superclass. It plays a crucial role in identifying any discrepancies if the function signature does not align with the base class function.

1. Creating Instances and Invoking the Virtual Function: At this point, we are able to instantiate objects from both the superclass and the subclass followed by invoking the virtual function. Below is a demonstration illustrating how this process is carried out:

int main() {
    Base* basePtr;
    Base baseObj;
    Derived derivedObj;

    // Point to base class object
    basePtr = &baseObj;
    basePtr->virtualFunction();  // Calls Base class virtual function

    // Point to derived class object
    basePtr = &derivedObj;
    basePtr->virtualFunction();  // Calls Derived class virtual function

    return 0;
}

In this code snippet, basePtr represents a pointer pointing to an object of the Base class. Initially, it points to a Base object named baseObj. When the virtualFunction method is invoked through basePtr, it triggers the function's implementation specified in the class that the pointer references. Subsequently, basePtr is reassigned to point to an object of the Derived class, specifically derivedObj. Subsequent calls to virtualFunction now execute the overridden version present in the Derived class.

Comprehending Dynamic Dispatch: The process of invoking the accurate virtual function during program execution is referred to as dynamic dispatch. When we invoke a virtual function using a pointer or reference to a base class, the C++ runtime mechanism identifies the specific object type during runtime and executes the relevant function version according to the object's type.

Program:

Let's consider an instance to demonstrate how to invoke a virtual method from a subclass in the C++ programming language.

#include <iostream>

// Base class with a virtual function
class Animal {
public:
    virtual void makeSound() {
        std::cout << "Animal makes a sound\n";
    }
};

// Derived class overriding the virtual function
class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Dog barks\n";
    }
};

// Another derived class overriding the virtual function
class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "Cat meows\n";
    }
};

int main() {
    Animal* animalPtr;
    Dog dog;
    Cat cat;

    animalPtr = &dog;
    animalPtr->makeSound();  // Calls Dog's overridden function

    animalPtr = &cat;
    animalPtr->makeSound();  // Calls Cat's overridden function

    return 0;
}

Output:

Dog barks
Cat meows

Explanation:

• ✅ Base Class with Virtual Function: In this example, we have a base class called Animal, which has a virtual function called makeSound. It is indicated by using the keyword "virtual". It can be overridden in derived classes. A default definition for makeSound method is given by this class itself
• ✅ Derived Classes and Overriding: The code also demonstrates two derived classes: Dog and Cat both inheriting from the Animal baseclass. These classes override the method makeSound with their own versions; one makes a dog bark noise while another makes cat meow sound
• ✅ Dynamic Dispatch and Polymorphism: In the key function, two objects of type Cat and Dog are created (cat and dog respectively). These objects are pointed to at differencpp tutorials in time using a pointer of type Animal* (animalPtr). It shows polymorphism and dynamic dispatch. If animalPtr points to a Dog object and makeSound is called through it, the makeSound function in the Dog class that has been overridden ("Dog barks") will be executed. Similarly, if animalPtr points to a Cat object, it refers back to the Cat class where we have also overridden this method ("Cat meows").
• ✅ Benefits and Use Cases: Inheritance along with virtual functions promotes reusability and flexibility because it allows us to write once use many times. It gives an opportunity to define a common interface within the base class which is further implemented differently by derived classes like Dog or Cat etc., through methods such as makeSound. This approach becomes particularly handy when there is need for dealing with various kinds of objects but all having some similarity somewhere hence creating them under one umbrella so that it can be easy for anyone working on those modules later during maintenance phase since they are more modularized.

Advantages:

• ✅ Polymorphism: Virtual functions allow polymorphism, which means that it enables us to write code that works with objects from various derived classes but through a common base class interface. This concept enhances flexibility and reusability of codes by giving a definition of only one function signature that has many implementations depending on the actual object type during runtime.
• ✅ Code Organization and Modularity: Inheritance along with virtual functions is helpful when organizing code hierarchically. Base classes establish shared interfaces and functionalities while derived classes provide specific ones. It makes it possible for different parts of the program to be isolated and managed separately thereby promoting modularity.
• ✅ Extensibility: By using virtual functions, we can easily extend functionality without altering any existing codes. Additional behaviours or features which enhance capabilities of the application without affecting the already written portions can be introduced into this system through new subclasses being added into this hierarchy.
• ✅ Dynamic Dispatch: The appropriate function implementation is called at runtime based on the actual object type as determined by dynamic dispatching feature in C++ through virtual functions. This behaviour is necessary for achieving polymorphic behaviour hence enabling runtime adaptability and flexibility in an object-oriented design.
• ✅ Abstraction and Encapsulation: Inheritance and the support of virtual functions is an important part in realizing abstraction as well as encapsulation. In this case, what it means is that while interfaces are defined on the base classes without specifying exact implementation details, data together with behaviour get packaged within classes thus separating different concerns clearly.
• ✅ Reduced Code Redundancy: Virtual functions reduce the repetition of codes by allowing for common functionalities to be written once in a base class and used again in other derived classes through inheritance. As a result, programs become shorter which makes them easier to maintain.
• ✅ Run-Time Flexibility: Polymorphism at run time becomes possible due to virtual functions because they enable this kind of behaviour where decisions about calling which function can be postponed until when program is running. Such flexibility during runtime becomes very useful especially when dealing with user interfaces or simulations since behaviours may change or object types may differ at various points during execution of a program.

In reality, leveraging virtual methods and inheritance in C++ improves the ability to reuse code, create modular structures, extend functionality, and adjust behavior at runtime. These design principles play a crucial role in promoting sound software development practices, thereby streamlining the development and upkeep of intricate systems.

Conclusion:

In C++, invoking a virtual method from a subclass entails defining a base class containing a virtual method, inheriting a class that redefines the virtual method, and subsequently employing pointers or references of the base class to invoke the virtual method based on the object's specific type during program execution. Grasping these principles is essential for incorporating polymorphism and establishing adaptable, maintainable code in C++.