In-depth Analysis of Virtual Functions vs Pure Virtual Functions in C++: From Polymorphism to Abstract Class Implementation

Fundamental Concepts and Implementation Mechanisms of Virtual Functions

Virtual functions serve as the core mechanism for implementing runtime polymorphism in C++. When a member function is declared as virtual in a base class, it allows derived classes to override the function and provide implementations specific to their type. The key aspect of this mechanism is that when a virtual function is called through a base class pointer or reference, the actual function executed corresponds to the dynamic type of the object.

class Base {
public:
    virtual void display() {
        std::cout << "Base class display" << std::endl;
    }
};

class Derived : public Base {
public:
    void display() override {
        std::cout << "Derived class display" << std::endl;
    }
};

int main() {
    Derived d;
    Base& rb = d;
    rb.display();  // Output: Derived class display
    return 0;
}

In the example above, although rb is a reference to the base class Base, because display() is a virtual function, the actual call invokes the overridden version in the Derived class. This dynamic binding mechanism enables the program to select the correct function implementation based on the object's actual type at runtime.

Definition of Pure Virtual Functions and Abstract Classes

Pure virtual functions are defined by appending = 0 to their declaration, explicitly indicating that the function has no default implementation. A class containing pure virtual functions automatically becomes an abstract class and cannot be directly instantiated.

class AbstractBase {
public:
    virtual void pureVirtualFunction() = 0;
    virtual ~AbstractBase() = default;
};

class ConcreteDerived : public AbstractBase {
public:
    void pureVirtualFunction() override {
        std::cout << "Implemented pure virtual function" << std::endl;
    }
};

// AbstractBase ab;  // Error: cannot instantiate abstract class
ConcreteDerived cd;  // Correct: derived class implements all pure virtual functions

Pure virtual functions compel derived classes to provide concrete implementations; otherwise, the derived classes also become abstract. This mechanism is particularly useful for defining interfaces and enforcing specific behaviors, especially when designing frameworks and libraries.

Key Differences in Syntax and Semantics

From a syntactic perspective, the primary distinction between virtual and pure virtual functions lies in their declaration. Virtual functions can have concrete implementations in the base class, whereas pure virtual functions explicitly indicate no implementation via = 0.

// Virtual function declaration and definition
virtual void regularVirtual() { /* implementation code */ }

// Pure virtual function declaration
virtual void pureVirtual() = 0;

Semantically, virtual functions provide an optional overriding mechanism, allowing derived classes to choose whether to override the base class implementation. In contrast, pure virtual functions establish a mandatory contract that any non-abstract derived class must fulfill by providing a concrete implementation.

Behavioral Differences at Compile Time and Runtime

Virtual and pure virtual functions are handled differently at compile time. For classes containing virtual functions, the compiler generates a virtual function table (vtable) to support runtime polymorphism. Conversely, abstract classes with pure virtual functions are prevented from instantiation during compilation.

class BaseWithVirtual {
public:
    virtual void func() {}
    // Can be instantiated
};

class AbstractWithPureVirtual {
public:
    virtual void func() = 0;
    // Cannot be instantiated
};

BaseWithVirtual b1;           // Correct
// AbstractWithPureVirtual a1; // Compilation error

In derived classes, failure to implement all pure virtual functions from the base class results in the derived class being treated as abstract. This cascading abstractness ensures the integrity of interface contracts.

C++11 New Features and Related Syntax

C++11 introduced the delete and default keywords, whose syntax resembles pure virtual function declarations but carries entirely different semantics.

class ModernClass {
public:
    ModernClass() = default;
    ModernClass(const ModernClass&) = delete;        // Disable copy construction
    ModernClass& operator=(const ModernClass&) = delete; // Disable copy assignment
    virtual void interface() = 0;                    // Pure virtual function
};

= delete is used to explicitly delete functions, preventing their invocation; = default explicitly requests the compiler to generate default implementations; and = 0 is specifically for declaring pure virtual functions. Understanding these syntactic differences is crucial for writing modern C++ code.

Practical Application Scenarios and Best Practices

Virtual functions are commonly used to implement polymorphic behavior, enabling base class pointers to invoke specific implementations in derived classes. This pattern is widely applied in GUI frameworks, game engines, and plugin systems.

class Shape {
public:
    virtual double area() const { return 0.0; }
    virtual ~Shape() = default;
};

class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override {
        return 3.14159 * radius * radius;
    }
};

class Rectangle : public Shape {
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double area() const override {
        return width * height;
    }
};

Pure virtual functions are more suitable for defining interface contracts, ensuring that all concrete implementation classes provide necessary functionalities. They play a key role in design patterns such as Factory, Strategy, and Observer patterns.

Advanced Feature: Implementation of Pure Virtual Functions

Although pure virtual functions typically lack implementations, C++ permits defining them. This feature can be useful in specific scenarios, such as providing optional default implementations for derived classes.

class Interface {
public:
    virtual void mustImplement() = 0;
};

// Pure virtual functions can also have implementations
void Interface::mustImplement() {
    std::cout << "Default implementation" << std::endl;
}

class Implementation : public Interface {
public:
    void mustImplement() override {
        Interface::mustImplement();  // Call base class implementation
        std::cout << "Extended implementation" << std::endl;
    }
};

While this usage is uncommon, it is valuable when common helper functionality or default behavior is needed for pure virtual functions. Derived classes can choose whether to invoke the base class implementation.

Summary and Performance Considerations

Both virtual and pure virtual functions are essential components of C++ polymorphism, but they differ fundamentally in design intent and usage scenarios. Virtual functions offer flexible overriding mechanisms, while pure virtual functions enforce interface implementation.

In terms of performance, virtual function calls involve additional indirection (via vtable) and may be slightly slower than non-virtual function calls. However, in most modern systems, this overhead is negligible, especially when weighed against the design flexibility they provide.

The choice between virtual and pure virtual functions should be based on specific design needs: use virtual functions when optional, overridable functionality is required; use pure virtual functions when mandatory interface contracts must be defined.