Difference between a virtual function and a pure virtual function

In object-oriented programming, virtual functions and pure virtual functions are fundamental concepts for implementing polymorphism. Both are specific to C++ and have several key differences.

Virtual Function

A virtual function is a member function declared in a base class that can be overridden in derived classes. It enables derived classes to redefine or customize the behavior of the base class as needed. When a function is called through a base class pointer or reference, the C++ runtime system ensures that the appropriate derived class function is invoked, demonstrating polymorphism.

Example:

Suppose there is a base class Animal and two derived classes Dog and Cat. In the Animal class, there is a virtual function makeSound(), which can be overridden in the Dog and Cat classes.

cpp
class Animal {
public:
    virtual void makeSound() {
        cout << "Some generic sound" << endl;
    }
};

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

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

When calling makeSound() through an Animal pointer or reference, it invokes the appropriate function based on the actual object type.

Pure Virtual Function

A pure virtual function is declared in a base class without any implementation, specified with = 0. A class that declares one or more pure virtual functions is called an abstract class. Abstract classes cannot be instantiated and are used as a base for derived classes.

Example:

Suppose the Animal class is an abstract concept and should not be instantiated directly. We can declare makeSound() as a pure virtual function.

cpp
class Animal {
public:
    virtual void makeSound() = 0;  // Pure virtual function
};

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

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

In this case, any attempt to instantiate an Animal object results in a compilation error, ensuring the purity of the abstract class.

Summary

Virtual functions allow derived classes to override base class methods, while pure virtual functions require derived classes to implement the function, enabling stricter abstraction. Virtual functions can have a default implementation, whereas pure virtual functions cannot. By utilizing these concepts, more flexible and robust class hierarchies can be designed, promoting code reuse and extensibility. In C++, both virtual functions and pure virtual functions are used to implement polymorphism, but they have key differences:

1. Virtual Function:

   • A virtual function is a member function that can be overridden in derived classes, declared with the virtual keyword in the base class. When called through a base class pointer or reference, it invokes the appropriate function based on the actual object type, a mechanism known as dynamic binding or late binding.
   • Virtual functions can have a default implementation, meaning the base class provides a basic behavior.

   Example:

   cpp
   

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

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

shell

   In this example, `speak` is a virtual function with a default implementation in the base class `Animal`. When you create a `Dog` object and call `speak` through an `Animal` reference or pointer, it invokes the `speak` function in the `Dog` class.

2. **Pure Virtual Function**:
   - A pure virtual function is declared in the base class without any implementation, requiring any non-abstract derived class to provide an implementation. It is declared with `= 0`.
   - If a class contains at least one pure virtual function, it becomes an abstract class and cannot be instantiated.

   **Example**:
   ```cpp
class Animal {
public:
    virtual void speak() = 0; // Pure virtual function
};

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

In this example, speak is a pure virtual function, making Animal an abstract class that cannot be directly instantiated. All derived classes from Animal (such as Dog) must implement speak to be instantiable.

Overall, virtual functions allow a default implementation in the base class, while pure virtual functions enforce that derived classes provide an implementation. Both mechanisms support polymorphism, where the same operation can have different implementations on different objects.