🧩 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

Feature	Abstract Class	Interface (in C++ style)
Purpose	Partial implementation + abstraction	Full abstraction only
Members	Can include non-pure functions	All functions are pure virtual
Variables	Can have member variables	Typically avoids data members
Instantiation	❌ No	❌ No

---

💡 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.

---

Share Now :