Virtual Function in C++

1️⃣ What is a Virtual Function?

A virtual function in C++ is a member function in a base class that can be overridden in a derived class.
When accessed via a base class pointer, the function call is resolved at runtime (dynamic binding) instead of compile-time (static binding).

Key Features:

✅ Declared using the virtual keyword in the base class.
✅ Allows runtime polymorphism (dynamic method dispatch).
✅ The derived class must override the function for it to work dynamically.
✅ If a derived class does not override, the base class function is used.

---

2️⃣ Syntax of a Virtual Function

class Base {
public:
    virtual void functionName() {  
        // Virtual function in the base class
    }
};

🔹 virtual keyword enables runtime method binding.

---

3️⃣ Example: Without virtual (Static Binding)

#include <iostream>
using namespace std;

class Base {
public:
    void show() {  // No virtual keyword
        cout << "Base class function" << endl;
    }
};

class Derived : public Base {
public:
    void show() {  // Overriding the function
        cout << "Derived class function" << endl;
    }
};

int main() {
    Derived d;
    Base* ptr = &d;  // Base class pointer pointing to derived class object
    ptr->show();  // Calls Base class function (STATIC BINDING)

    return 0;
}

🔹 Output

Base class function

🔴 Problem: Even though ptr points to Derived, it still calls Base::show().
🔴 Reason: Function binding happens at compile-time (static binding).

---

4️⃣ Example: Using virtual (Dynamic Binding)

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() {  // Virtual function
        cout << "Base class function" << endl;
    }
};

class Derived : public Base {
public:
    void show() override {  // Overriding the function
        cout << "Derived class function" << endl;
    }
};

int main() {
    Derived d;
    Base* ptr = &d;  // Base class pointer holding derived class object
    ptr->show();  // Calls Derived class function (DYNAMIC BINDING)

    return 0;
}

🔹 Output

Derived class function

✅ Now, Derived::show() is called dynamically at runtime!
✅ This is because virtual functions enable dynamic dispatch.

---

5️⃣ Virtual Function with Multiple Derived Classes

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void makeSound() {
        cout << "Animal makes a sound" << endl;
    }
};

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

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

int main() {
    Dog d;
    Cat c;
    Animal* ptr;

    ptr = &d;
    ptr->makeSound(); // Calls Dog::makeSound()

    ptr = &c;
    ptr->makeSound(); // Calls Cat::makeSound()

    return 0;
}

🔹 Output

Dog barks
Cat meows

✅ The correct function is called dynamically at runtime.

---

6️⃣ Pure Virtual Function & Abstract Classes

A pure virtual function has no definition in the base class and forces derived classes to override it.
Classes with at least one pure virtual function are called abstract classes.

Example

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() = 0;  // Pure virtual function
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing Circle" << endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        cout << "Drawing Rectangle" << endl;
    }
};

int main() {
    Shape* s1 = new Circle();
    Shape* s2 = new Rectangle();

    s1->draw();  // Calls Circle::draw()
    s2->draw();  // Calls Rectangle::draw()

    delete s1;
    delete s2;

    return 0;
}

🔹 Output

Drawing Circle
Drawing Rectangle

✅ Why use pure virtual functions?
✔ Forces derived classes to implement their own versions.
✔ Used in interfaces and abstract base classes.

---

7️⃣ Key Points About Virtual Functions

✔ Declared in the base class using virtual.
✔ Overridden in the derived class.
✔ Enables dynamic binding (method selection happens at runtime).
✔ Allows polymorphism (same interface, different behavior).
✔ Abstract classes have at least one pure virtual function.

Would you like an example of virtual destructors? 🚀