Virtual Functions and Dynamic Polymorphism in C++
Virtual functions and dynamic polymorphism in the C++ programming language are among the most advanced functions and features of object-oriented programming. They allow C++ users to apply class behavior properties that vary based on the data type of the class object being referenced in the current class, rather than the data type of the object reference or pointer used in the class. Virtual functions and dynamic polymorphism are essential for C++ programmers to create flexible and extensible program source code, especially in particular situations where C++ programmers work with class hierarchies.
What are virtual functions in C++ programming?
A virtual function declared in a C++ class program is defined as a member function in the base class, which has the potential to be overridden by a C++ user in a derived class or subclass. When a C++ user calls a virtual function in a class object, it is called. So, C++ programming in runtime mode will dynamically determine which version of the function to invoke in the current class. This will depend entirely on the actual class object data type (not the reference or pointer type).
Important features of virtual functions in C++ programming.
- C++ users can declare virtual functions by using the virtual keyword in the base parent class.
- If a function is overridden in a derived class subclass, the derived class’s version is called in this condition, regardless of whether the C++ user is using a class pointer or reference to the base or root class.
- This mechanism processes the proper exact class function at runtime based on the actual class object data type. This is known as dynamic dispatch.
Syntax of virtual functions in C++.
class Base {
public:
virtual void virFunction() {
std::cout << “virFunction in the base or parent class” << std::endl;
}
};
class Derived : public Base {
public:
void virFunction() override { // Here the virtual function is overridden
std::cout << “virFunction version in the derived class” << std::endl;
}
};
Virtual functions syntax in C++.
- Here, C++ users use the virtual keyword in the current class to declare a function in the base class as virtual.
- In the derived class or subclass, the class function is overridden. This is similar to the optional override keyword in C++11 and later.
Why use virtual functions in C++?
Virtual functions in C++ programming are used to support the concept of dynamic polymorphism within a class. The behavior of a virtual function defined in a class can vary depending on the actual data type of the class object, not just the type of the class object pointer or reference.
How virtual functions work in C++.
When a user-defined class function is called through a base class pointer or reference, C++ programming determines at runtime which class function to call based on the actual class object data type (i.e., the data type of the object being pointed to in the current class program), rather than the data type of the pointer.
This feature is implemented in C++ programming using a vtable (virtual table), which is a table of function pointers to all virtual functions in a class that is maintained in real time.
Example of a virtual function in C++ programming.
#include <iostream>
using namespace std;
class Course {
Public:
virtual void select() { //course class select virtual function created
cout << “Select your desire Course ” << endl;
}
virtual ~Course() { // here we create virtual destructor for proper cleanup
cout << “Course class destructor created” << endl;
}
};
class Cplus : public Course {
Public:
void select() override { // here we are overriding the base class function method
cout << “Cplus derived class created” << endl;
}
~Cplus() { // here we created destructor of Cplus class
cout << “Cplus class destructor created” << endl;
}
};
class Python : public Course {
Public:
void select() override { //here we are overriding the base class function
cout << “Python subclass created ” << endl;
}
~Python() { // here we created destructor of Python class
cout << “Python destructor created” << endl;
}
};
int main() {
Course* coursefirst = new Cplus(); // here we define base class pointer pointing to derived class object
Course* coursesecond = new Python();
coursefirst->select(); // here it calls Cplus select() function
coursesecond->select(); // here it calls Python select() function
deletecoursefirst; //here it Deletes Cplus class object
delete coursesecond; //here it Deletes Python class object
return 0;
}
Explanation of a virtual function in C++ programming.
- In this example, the select() function is declared as a virtual function in the Course class, and both Cplus and Python override it with class methods.
- In the main() class function, C++ users create a Cplus and a Python class object. However, C++ users reference them using a pointer of type CourseClass*.
- When we call the select() function in the Course base class, the proper class version is invoked based on the actual class object type (not the pointer type).
- This is a core feature of dynamic polymorphism in C++ programming, providing the ability to call overridden methods on objects of derived class subclasses even when using base class pointers.
