Updated on 27th Dec, 23 9.1K Views

In this blog, we will be learning all about virtual functions in C++. We will discuss what they are, their rules, how to use them, and the differences between compile-time and runtime behaviors of virtual functions. Additionally, we will also be learning pure virtual functions, providing an overview of their role in C++ programming.

Table of Contents

Check out our YouTube video on C programming language for the absolute beginners:

What is a Virtual Function in C++?

In C++, a virtual function is a member function within a base class that’s designed to be overridden in its derived classes. It allows a specific function to be reimplemented in the derived class while preserving a common interface across all derived classes. This concept is required for implementing runtime polymorphism.

When a function is declared “virtual” in a base class, it enables late binding or dynamic binding that ensures the correct overridden function in the derived class is invoked during runtime. This feature executes the function of the derived class when a pointer or reference to the base class type is used. Virtual functions make code more flexible by using a dynamic method of resolution that provides efficient utilization of polymorphism in complex object-oriented designs.

Want to jumpstart your career in Computer Programing? Enrol in our C Programming Course and gain your skills to succeed!

Rules of Virtual Functions in C++

Virtual function rules are important to ensure a consistent and structured approach while implementing dynamic polymorphism in C++. Here are the rules that must be followed while writing a virtual function in C++:

  • Virtual functions cannot be static and must be declared in the base class to be overridden in derived classes.
  • Friend functions can be virtual, offering access to private or protected members of the class.
  • To achieve runtime polymorphism, virtual functions should be accessed through pointers or references of the base class.
  • The prototype of virtual functions must match both the base and derived classes for proper overriding.
  • Overriding a virtual function in derived classes is optional; otherwise, the base class’s version is used.
  • While a class can have a virtual destructor, a virtual constructor is not permitted in C++.

Check out our blog on What is Friend Function in C++? to learn more about C++ and its functions.

How to Use a Virtual Function in C++

To use a virtual function in C++, follow these steps:

  • Define a virtual function in the base class by declaring it with the “virtual” keyword.
  • Implement the virtual function in the base class.
  • Optionally, override the virtual function in derived classes to provide specific implementations.
  • Access the virtual function through a pointer or reference to the base class to achieve dynamic binding at runtime.
  • Utilize the virtual function in your code to enable polymorphic behavior based on the actual object type.

Get 100% Hike!

Master Most in Demand Skills Now !

Example of a Virtual Function in C++

In C++, a virtual function enables runtime polymorphism, allowing a base class pointer to call overridden functions in derived classes. Let’s consider an example with a base class Shape and its derived classes Circle and Square, each having its own draw() method.

#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* shape1 = new Circle();
    Shape* shape2 = new Square();
    shape1->draw();  // Calls Circle's draw()
    shape2->draw();  // Calls Square's draw()
    delete shape1;
    delete shape2;
    return 0;
}

In the above example, Base Class ‘Shape’ contains a virtual function draw() that serves as an interface for its derived classes. This function is marked as virtual, indicating that it can be overridden by derived classes. Both derived classes, Circle and Square, inherit from the Shape class and override the draw() function with their specific implementations. Pointers of the base class type (Shape*) are used to hold derived class objects Circle and Square. When calling shape1->draw() or shape2->draw(), even though the pointers are of type Shape*, the appropriate derived class’s draw() method is invoked. This happens because of the implementation of late binding or runtime polymorphism by the virtual function. It allows the correct overridden method draw() of class Circle or Square to be called based on the actual object type.

Check out C and Data Structure Interview Questions to crack your next interview!

Compile Time (Early Binding) Vs. Runtime (Late Binding) Behavior

This table summarizes the key distinctions between early binding and late binding behaviors by virtual functions based on characteristics in terms of method resolution, flexibility, performance, and usage in C++.

AspectCompile-Time (Early Binding)Runtime (Late Binding)
Method ResolutionResolved at compile timeExecuted until runtime (dynamically determined)
Decision TimingMethod call determined by pointer/reference typeMethod call determined by the object’s actual type
FlexibilityLimited polymorphism and extensibilityEnhanced polymorphism, allowing for code extensibility
PerformanceFaster execution due to static bindingSlightly slower execution due to dynamic binding
Function Call ResolutionBound directly to the method associated with the typeInvokes the appropriate derived class method
UsageNon-virtual functions and regular member functionVirtual functions enabling runtime polymorphism

Career Transition

Non-Tech to IT Associate | Career Transformation | AWS Certification Course - Intellipaat Reviews
Non Tech to DevOps Engineer Career Transition | Intellipaat Devops Training Reviews - Nitin
Upskilled & Got Job as Analyst After a Career Break |  Data Science Course Story - Shehzin Mulla
Successful Career Change after Completion of AWS Course - Krishnamohan | Intellipaat Review
Got Job Promotion After Completing Artificial Intelligence Course - Intellipaat Review | Gaurav
Intellipaat Reviews | Big Data Analytics Course | Career Transformation to Big Data | Gayathri

Pure Virtual Function in C++

A pure virtual function in C++ is a virtual function that is declared in a base class but has no implementation provided in that class. It is denoted by assigning 0 to the function declaration, making it mandatory for any derived class to implement it. Classes containing pure virtual functions are known as abstract classes and cannot be instantiated; they are designed to serve as base classes for other classes to inherit from.

#include <iostream>
// Abstract class with a pure virtual function
class Shape {
public:
    // Pure virtual function
    virtual void area() = 0;
};
// Derived class implementing the pure virtual function
class Circle : public Shape {
public:
    void area() override {
        std::cout << "Area of circle: πr^2" << std::endl;
    }
};
int main() {
    // Shape* pointer to Circle object
    Shape* shape = new Circle();
    shape->area(); // Calls the overridden area() function in Circle
    delete shape; // Free memory
    return 0;
}

In the above example, the Shape class contains a pure virtual function area() with no implementation. The Circle class inherits from Shape and provides an implementation for the area() function. In the main() function, a pointer of type Shape is created and assigned the address of a Circle object. When shape->area() is called, it invokes the overridden area() function in Circle, printing the area of the circle.

Conclusion

Understanding virtual functions in C++ is fundamental for achieving polymorphic behavior and implementing runtime binding. They enable dynamic method resolution, allowing different classes to override base class functions and facilitating flexibility and extensibility in object-oriented programming. The concept of virtual functions enhances code reusability, scalability, and the creation of robust class hierarchies. Embracing virtual functions optimizes code structure and facilitates the development of efficient, maintainable software systems.

Don’t miss out on the latest programming trends and advancements – be part of Intellipaat’s Community today!

Course Schedule

Name Date Details
Python Course 02 Mar 2024(Sat-Sun) Weekend Batch
View Details
Python Course 09 Mar 2024(Sat-Sun) Weekend Batch
View Details
Python Course 16 Mar 2024(Sat-Sun) Weekend Batch
View Details

Leave a Reply

Your email address will not be published. Required fields are marked *

Speak to our course Advisor Now !

Subscribe to our newsletter

Signup for our weekly newsletter to get the latest news, updates and amazing offers delivered directly in your inbox.