What are virtual functions? Explain with suitable program.

Virtual Functions:

Virtual functions are a fundamental concept in object-oriented programming that enable the implementation of polymorphism, allowing objects of different classes to respond to the same method call with different behaviors. Virtual functions are declared with the virtual keyword in the base class and overridden in derived classes to provide specific implementations for each class.

Understanding Virtual Functions:

1. Polymorphism: Virtual functions allow for polymorphism, where objects of different classes can be treated as objects of a common base class and respond to the same method calls with distinct behaviors.

2. Late Binding: Virtual functions are dynamically bound at runtime, meaning the specific implementation of a method to be executed is determined at runtime based on the actual object type. This is in contrast to early binding, where the method implementation is determined at compile time based on the static type of the object.

3. Base Class Pointer: Virtual functions are typically accessed through a pointer to the base class, enabling the same method call to invoke different implementations in derived classes.

Program Example:

To illustrate virtual functions, consider the following program:

#include 

using namespace std;

class Animal {
public:
    virtual void speak() {
        cout << "Animal speaks!" << endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        cout << "Dog barks!" << endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        cout << "Cat meows!" << endl;
    }
};

int main() {
    // Create instances of Animal, Dog, and Cat
    Animal* animal = new Animal();
    Dog* dog = new Dog();
    Cat* cat = new Cat();

    // Invoke the speak() method through base class pointers
    animal->speak();  // Output: "Animal speaks!"
    dog->speak();     // Output: "Dog barks!"
    cat->speak();     // Output: "Cat meows!"

    return 0;
}

Explanation:

1. In this example, we create a base class Animal with a virtual method speak. This method is intended to be overridden in derived classes.

2. We have two derived classes, Dog and Cat, that inherit from Animal. Each derived class overrides the speak method to provide its own implementation for how a dog barks or a cat meows.

3. We create instances of Animal, Dog, and Cat and store them in pointers to the base class Animal. This allows us to invoke the speak method through the base class pointer.

4. When the speak method is called through the base class pointer, the specific implementation to be executed is determined at runtime based on the actual object type. This is known as late binding or dynamic binding.

5. As a result, when animal->speak() is called, the output is "Animal speaks!", when dog->speak() is called, the output is "Dog barks!", and when cat->speak() is called, the output is "Cat meows!".

Virtual functions provide a powerful mechanism for implementing polymorphism and enable flexible and extensible object-oriented designs.