Why is a pure virtual function initialized by 0?

In C++, pure virtual functions are denoted by = 0, which is a syntax rule to explicitly mark a function as pure virtual, thereby making the class it belongs to an abstract class. The primary purpose of pure virtual functions is to require that any derived class from this abstract class must implement the pure virtual function, enabling the creation of objects of the derived class.

Pure Virtual Functions: Definition and Purpose

Pure virtual functions are typically declared in a base class without providing a concrete implementation (i.e., the function body is empty), and are specified by appending = 0 at the end of the function declaration. Such a function is defined as follows:

cpp
class Base {
public:
    virtual void show() = 0;  // pure virtual function
};

Here, the show() function is a pure virtual function. Because it is declared with = 0, it makes the Base class an abstract class. This means you cannot directly instantiate objects of the Base class; instead, you must derive from it, and the derived classes must provide a concrete implementation of the show() function.

Example: Using Pure Virtual Functions

Let's understand the purpose of pure virtual functions through an example.

cpp
class Animal {
public:
    virtual void speak() = 0;  // pure virtual function, making Animal an abstract class
};

class Dog : public Animal {
public:
    void speak() override {  // Providing concrete implementation in derived class
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {  // Providing concrete implementation in derived class
        std::cout << "Meow!" << std::endl;
    }
};

In this example, the Animal class contains a pure virtual function speak(). This requires that any class derived from Animal, such as Dog and Cat, must provide an implementation of the speak() function. This mechanism ensures that all animal types have their own way of speaking, and this behavior is enforced at compile time, thereby improving the safety and robustness of the code.

Summary

By denoting functions with = 0, the pure virtual function pattern in C++ forces derived classes to implement specific functions, which is crucial for polymorphism and interface specification in object-oriented design. It ensures that the design intent of the base class is maintained while supporting runtime polymorphism.