C++ Pure Virtual Functions – Abstract Classes & Interfaces Explained

Introduction – Why Use Pure Virtual Functions in C++

In C++ object-oriented programming, pure virtual functions define abstract behavior—forcing derived classes to provide their own implementation. This enables creation of interfaces and enforces consistent method structures in derived classes.

In this guide, you’ll learn:

• What pure virtual functions are
• How to declare abstract classes and interfaces
• Syntax and real-world examples
• Best practices for polymorphic design

What Is a Pure Virtual Function?

A pure virtual function is a virtual function that has no implementation in the base class. It is declared by assigning = 0 in its declaration.

A class with at least one pure virtual function becomes an abstract class, which:

• Cannot be instantiated
• Must be inherited and overridden

Code Examples – With Output

Example 1: Basic Pure Virtual Function

#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;
    }
};

int main() {
    // Shape s;          //  Error: Cannot instantiate abstract class
    Circle c;
    c.draw();              //  Valid
    return 0;
}

Output:

Drawing Circle

Explanation:

• Shape is an abstract class due to draw() = 0
• Circle must override draw() or remain abstract

Example 2: Interface-style Class with Multiple Pure Virtual Functions

class IPrinter {
public:
    virtual void print() = 0;
    virtual void scan() = 0;
};

class LaserPrinter : public IPrinter {
public:
    void print() override {
        cout << "Laser printing..." << endl;
    }
    void scan() override {
        cout << "Scanning document..." << endl;
    }
};

Note: You can use abstract classes to define interfaces (just like in Java or C#).

Abstract Class Structure

class AbstractBase {
public:
    virtual void doWork() = 0;     // Pure virtual
    void utilityMethod() {         // Concrete method
        cout << "Helper logic" << endl;
    }
};

Abstract classes can also have:

• Constructors
• Data members
• Non-pure (concrete) methods

Abstract Classes vs Interfaces

Best Practices & Tips

Best Practice: Use abstract classes when some shared logic is needed; use pure interface classes for behavior contracts.

Tip: Use override in derived classes to ensure correct method overriding.

Pitfall: Forgetting to implement all pure virtual functions makes the derived class abstract and uninstantiable.

Use Cases for Pure Virtual Functions

Document Rendering: Document → PDF, DOCX, PPT with render() override
Game Entities: Entity → Player, Enemy each override update()
Plugin Frameworks: IPlugin interface ensures every plugin has init() and execute()
Device Drivers: Abstract Device interface with read() and write() functions

Summary – Recap & Next Steps

Key Takeaways:

• Pure virtual functions define interfaces for derived classes
• Abstract classes cannot be instantiated directly
• Ensure all pure virtual methods are overridden in concrete classes

Real-World Relevance:
Used in GUI frameworks, plugin architectures, simulation engines, data pipelines, and modular APIs.

Next Steps:

• Learn about Interfaces in C++ using Abstract Classes
• Explore Virtual Destructors and Clean Class Hierarchies

FAQ – C++ Pure Virtual Functions

What is the syntax of a pure virtual function?
virtual void functionName() = 0;

Can an abstract class have normal (non-virtual) functions?
Yes. You can mix pure virtual and concrete methods in abstract classes.

Can constructors be pure virtual?
No. Constructors can’t be virtual or pure virtual.

Can a pure virtual function have a body?
Yes, but it’s rare. You can define it outside the class, though it’s still pure.

How is this different from virtual functions?
Virtual functions have default behavior. Pure virtual functions have no implementation—they must be overridden.