Understanding Function Overriding and Virtual Functions in C

Introduction

In the context of object-oriented programming, function overriding and virtual functions are important concepts that help achieve runtime polymorphism, making programs more flexible and extendable. This article aims to provide a clear understanding of these concepts and how they are used in C .

Function Overriding

Function overriding occurs when a derived class (child class) provides a specific implementation of a function that has already been defined in its base class (super class). The function in the derived class has the same name, return type, and parameters as the function in the base class.

Function overriding is particularly useful for achieving runtime polymorphism. This means that the appropriate function (inherited or overridden) will be called based on the object's actual type at runtime, rather than at compile time. This is especially useful when a base class pointer or reference is pointing to an object of a derived class.

How Function Overriding Works

Function overriding is achieved by defining a function with the same name and parameters in the derived class. It doesn't require any special keyword or syntax in C .

Consider the following example:

class Shape {public:  void draw() {    std::cout  "Shape is drawn.";  }};class Rectangle : public Shape {public:  void draw() {    std::cout  "Rectangle is drawn.";  }};class Square : public Shape {public:  void draw() {    std::cout  "Square is drawn.";  }};int main() {  Shape s;  Rectangle ob1;  Square ob2;  Shape ob3  ob2;  // Polymorphism in action  s  ob3;  s.draw();  // Outputs "Square is drawn."  s  ob1;  s.draw();  // Outputs "Rectangle is drawn."  s  ob2;  s.draw();  // Outputs "Square is drawn."  s  ob2;  s.draw();  // Outputs "Square is drawn."  return 0;}

In this example, the Shape class has a draw method. Both Rectangle and Square classes override this method with their own implementation. When a Shape reference is assigned an instance of derived classes (like Rectangle and Square), the appropriate draw method of the derived class is invoked. This behavior is known as dynamic (or runtime) dispatch.

Virtual Functions

Virtual functions, on the other hand, are a way to ensure that function overriding works correctly in C . In C , if a base class function is not marked as virtual, the function call is made based on the type of pointer, not the actual object type. This can lead to incorrect behavior in situations where you have a base class pointer pointing to derived class objects.

For function overriding to work correctly, the function in the base class must be declared as virtual. The virtual keyword in C indicates that a function is a virtual function. A virtual function in the base class can be overridden in the derived class. The call to the virtual function is resolved at runtime, ensuring that the most appropriate version of the function is called.

Why Use Virtual Functions?

Virtual functions are crucial for dynamically bound polymorphism. They enable a function call to be executed based on the actual object type rather than the type of the reference or pointer at the call site. This is important for achieving polymorphic behavior through inheritance.

Consider the following example:

#include bits/stdc  .husing namespace std;class Shape {public:  virtual void draw() {  // Virtual function to support polymorphism    cout  "Shape is drawn."  endl;  }};class Rectangle : public Shape {public:  void draw() override {  // Overriding draw method    cout  "Rectangle is drawn."  endl;  }};class Square : public Shape {public:  void draw() override {  // Overriding draw method    cout  "Square is drawn."  endl;  }};int main() {  Shape s;  Rectangle ob1;  Square ob2;  Shape ob3  ob2;  // Polymorphism in action  s  ob3;  s.draw();  // Outputs "Square is drawn."  s  ob1;  s.draw();  // Outputs "Rectangle is drawn."  s  ob2;  s.draw();  // Outputs "Square is drawn."  s  ob2;  s.draw();  // Outputs "Square is drawn."  return 0;}

Here, the Shape class has a draw method that is marked as virtual. This ensures that the draw method is dynamically dispatched based on the actual object type. As a result, even when the Shape reference is assigned to an instance of the derived class (like Rectangle and Square), the correct draw method of the derived class is called.

Key Differences

The main differences between function overriding and virtual functions are:

Function Overriding: A derived class provides a specific implementation of a function that is already defined in the base class. It does not require the virtual keyword in the base class. Virtual Functions: A virtual function in the base class can be overridden in the derived class. It is crucial for achieving dynamic dispatch and ensuring that the correct function is called based on the actual object type.

Conclusion

Understanding the concepts of function overriding and virtual functions is essential for writing flexible and extendable C code that can handle polymorphism and runtime binding. By combining these concepts, you can create more robust and dynamic programs that can adapt to changing requirements.