In our previous lessons, we explored how inheritance allows one class to reuse and extend the features of another. We also learned about function overriding, where a derived class can redefine the behavior of a base class function.<\/p>\n\n\n\n
But there\u2019s a deeper question that often puzzles students:<\/p>\n\n\n\n
\nIf a base class pointer points to a derived class object, which version of the function will be called; the one from the base or the one from the derived class?<\/em><\/p>\n<\/blockquote>\n\n\n\n
This question brings us to an important concept called Virtual Functions<\/strong>, one of the most powerful features of polymorphism in C++.<\/p>\n\n\n\n
A simple way to define it is:<\/p>\n\n\n\n
\nA virtual function is a function in a base class that can be redefined in derived classes, and its call is resolved at runtime rather than compile time.<\/p>\n<\/blockquote>\n\n\n\n
In simpler terms, C++ waits until the program is running to decide which function version to call; depending on the type of object the pointer is actually pointing to.<\/p>\n\n\n\n
Real-Life Example: Employees and Their Duties<\/h2>\n\n\n\n
Imagine a company that hires many types of employees \u2014 teachers, engineers, and managers. Each of them performs a different duty, but the company only knows that everyone must perform duty<\/em>.<\/p>\n\n\n\n
The company management doesn\u2019t need to know the exact details of what each person does. It just asks the employee to perform the duty, and the employee responds according to their role.<\/p>\n\n\n\n
A teacher will teach, an engineer will design, and a manager will manage.<\/p>\n\n\n\n
This simple relationship reflects what virtual functions<\/strong> do in programming. The base class represents the company rule, and the derived classes represent the employees who perform different duties. When the company calls
performDuty()<\/code>, the correct action is performed depending on the actual employee type.<\/p>\n\n\n\nUnderstanding Virtual Functions Through Code<\/h2>\n\n\n\n
Let\u2019s now bring this idea into C++ with an example based on our company example.<\/p>\n\n\n\n
#include <iostream>\nusing namespace std;\n\n\/\/ Base class representing a generic employee\nclass Employee {\npublic:\n \/\/ Declaring a virtual function\n virtual void performDuty() {\n cout << \"Performing a general company duty.\" << endl;\n }\n};\n\n\/\/ Derived class representing a Teacher\nclass Teacher : public Employee {\npublic:\n void performDuty() override {\n cout << \"Teaching students and preparing lessons.\" << endl;\n }\n};\n\n\/\/ Derived class representing an Engineer\nclass Engineer : public Employee {\npublic:\n void performDuty() override {\n cout << \"Designing systems and writing code.\" << endl;\n }\n};\n\nint main() {\n Employee* staff; \/\/ Base class pointer\n\n Teacher t;\n Engineer e;\n\n staff = &t;\n staff->performDuty(); \/\/ Calls Teacher\u2019s version\n\n staff = &e;\n staff->performDuty(); \/\/ Calls Engineer\u2019s version\n\n return 0;\n}\n<\/code><\/pre>\n\n\n\nIn this program, the base class
Employee<\/code> declares the functionperformDuty()<\/code> as virtual.
BothTeacher<\/code> andEngineer<\/code> redefine this function in their own way.<\/p>\n\n\n\nWhen we use the base class pointer
staff<\/code> to point to aTeacher<\/code> object, it calls the teacher\u2019s version. When we point it to the engineer, it calls the engineer\u2019s version.<\/p>\n\n\n\nThis is called runtime polymorphism<\/strong> because the exact version of the function is decided at runtime, depending on the actual object being pointed to.<\/p>\n\n\n\n
If we had not used the
virtual<\/code> keyword, the compiler would have always called the base class version, ignoring the derived ones. That would be static binding<\/strong>. By declaring the function virtual, we enable dynamic binding<\/strong>; the true essence of polymorphism.<\/p>\n\n\n\nMoving Forward: The Need for Pure Virtual Functions<\/h2>\n\n\n\n
Sometimes, we don\u2019t even want the base class to provide any implementation. We just want it to declare what must<\/em> be done, leaving it to the derived classes to decide how<\/em> it\u2019s done.<\/p>\n\n\n\n
This situation is like a company rulebook that defines the responsibilities of all employees but doesn\u2019t describe how to perform them. Every employee must follow the rule and perform their specific duty.<\/p>\n\n\n\n
The rulebook is the abstract base class<\/strong>, and the rule itself \u2014 the declaration \u2014 is the pure virtual function<\/strong>.<\/p>\n\n\n\n
Code Example for Pure Virtual Function<\/h2>\n\n\n\n
#include <iostream>\nusing namespace std;\n\n\/\/ Abstract base class (acts like a rulebook)\nclass Employee {\npublic:\n \/\/ Pure virtual function - notice the = 0\n virtual void performDuty() = 0;\n};\n\n\/\/ Derived class: Teacher\nclass Teacher : public Employee {\npublic:\n void performDuty() override {\n cout << \"Teaching students and preparing lessons.\" << endl;\n }\n};\n\n\/\/ Derived class: Engineer\nclass Engineer : public Employee {\npublic:\n void performDuty() override {\n cout << \"Designing systems and writing code.\" << endl;\n }\n};\n\nint main() {\n \/\/ We cannot create an object of Employee (abstract class)\n \/\/ Employee e; \/\/ \u274c This will cause a compilation error\n\n Employee* staff; \/\/ Base class pointer\n\n Teacher t;\n Engineer e1;\n\n staff = &t;\n staff->performDuty(); \/\/ Calls Teacher\u2019s implementation\n\n staff = &e1;\n staff->performDuty(); \/\/ Calls Engineer\u2019s implementation\n\n return 0;\n}\n<\/code><\/pre>\n\n\n\nIn this example,
performDuty()<\/code> is declared as a pure virtual function<\/strong> using= 0<\/code>.
This means the base classEmployee<\/code> defines what every employee must do but doesn\u2019t explain how to do it. Each derived class provides its own version of the function.<\/p>\n\n\n\nA class that contains even one pure virtual function becomes an abstract class<\/strong>, meaning you cannot create its objects. Instead, it serves as a blueprint for other classes.<\/p>\n\n\n\n
If a derived class fails to implement the pure virtual function, it too becomes abstract and cannot create objects.<\/p>\n\n\n\n
This mechanism helps maintain consistency and ensures that all derived classes follow the same structure but with their own unique behavior.<\/p>\n\n\n\n
Connecting Back to the Concept<\/h2>\n\n\n\n
A virtual function<\/strong> gives flexibility. It allows a base class to provide a default version that can be overridden when necessary.<\/p>\n\n\n\n
A pure virtual function<\/strong> enforces a rule; it doesn\u2019t define any version and leaves the implementation entirely to derived classes.<\/p>\n\n\n\n
Both together form the foundation of polymorphism in C++: virtual functions enable runtime decisions<\/strong>, and pure virtual functions provide structured abstraction<\/strong>.<\/p>\n\n\n\n
In this way, C++ beautifully balances freedom and discipline \u2014 allowing you to create systems that are flexible, scalable, and logically consistent.<\/p>\n\n\n\n
Practice Task for You<\/h2>\n\n\n\n
Design a base class called
PaymentMethod<\/code> that declares a pure virtual function namedmakePayment()<\/code>. Then, create two derived classes \u2014CashPayment<\/code> andOnlinePayment<\/code>.<\/p>\n\n\n\nEach class should define its own version of
makePayment()<\/code> describing how the payment is processed. Finally, use a base class pointer to call both versions dynamically.<\/p>\n\n\n\nBy completing this, you will experience how abstraction<\/strong> and runtime polymorphism<\/strong> combine to make your programs cleaner and more powerful.<\/p>\n","protected":false},"excerpt":{"rendered":"
In our previous lessons, we explored how inheritance allows one class to reuse and extend the features of another. We also learned about function overriding, where a derived class can redefine the behavior of a base class function. But there\u2019s a deeper question that often puzzles students: If a base class pointer points to a derived class object, which version of the function will be called; the one from the base or the one from the derived class? This question…<\/p>\n