Pure virtual functions in C++ - Deep Dive

Overview - Pure virtual functions

What is it?

A pure virtual function in C++ is a special kind of function declared inside a class that has no implementation in that class. It forces any class that inherits from it to provide its own version of that function. This makes the class abstract, meaning you cannot create objects directly from it. Pure virtual functions help define a common interface for different classes.

Why it matters

Pure virtual functions exist to ensure that certain functions must be implemented by derived classes, enforcing a contract. Without them, there would be no way to guarantee that all subclasses provide specific behavior, leading to inconsistent or incomplete code. This helps in designing flexible and reusable software where different objects share a common interface but behave differently.

Where it fits

Before learning pure virtual functions, you should understand basic classes, inheritance, and virtual functions in C++. After mastering pure virtual functions, you can explore abstract classes, polymorphism, and design patterns like interfaces and strategy.

Mental Model

Core Idea

A pure virtual function is a placeholder in a base class that forces derived classes to fill in the details.

Think of it like...

Imagine a blueprint for a house that shows where the doors should be but leaves the exact design of each door to the builder. The blueprint says 'there must be a door here,' but the builder decides how it looks and works.

Base Class (Abstract)
┌─────────────────────────┐
│ + pureVirtualFunction() │  <-- No implementation here
└──────────┬──────────────┘
           │
           ▼
Derived Class 1           Derived Class 2
┌──────────────────────┐     ┌──────────────────────┐
│ + pureVirtualFunction()│  │ + pureVirtualFunction()│
│   (implemented)        │  │   (implemented)        │
└──────────────────────┘     └──────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Virtual Functions

Concept: Virtual functions allow derived classes to override methods of a base class to provide specific behavior.

In C++, a virtual function is declared in a base class using the keyword 'virtual'. It lets derived classes replace the base version with their own. When you call a virtual function through a base class pointer or reference, the program decides at runtime which version to use based on the actual object type.

Result

Calling a virtual function on a base pointer calls the derived class's version if overridden.

Understanding virtual functions is key because pure virtual functions build on this concept to enforce implementation.

2

Foundation

What is an Abstract Class?

Concept: An abstract class is a class that cannot be instantiated and usually contains at least one pure virtual function.

In C++, if a class has one or more pure virtual functions, it becomes abstract. You cannot create objects of an abstract class directly. It serves as a template for other classes to inherit from and implement the missing functions.

Result

Trying to create an object of an abstract class causes a compile-time error.

Knowing abstract classes helps you understand why pure virtual functions exist: to create templates that require specific behavior.

3

Intermediate

Declaring Pure Virtual Functions

🤔Before reading on: do you think a pure virtual function can have a body (implementation) in the base class? Commit to your answer.

Concept: A pure virtual function is declared by assigning 0 to the function declaration in the base class.

Syntax example: class Shape { public: virtual void draw() = 0; // pure virtual function }; This means 'draw' must be implemented by any class that inherits from Shape.

Result

Shape becomes an abstract class and cannot be instantiated.

Understanding the '= 0' syntax is crucial because it signals the compiler to enforce implementation in derived classes.

4

Intermediate

Implementing Pure Virtual Functions

🤔Before reading on: if a derived class does not implement all pure virtual functions, can you create its objects? Commit to your answer.

Concept: Derived classes must provide their own implementation of all pure virtual functions to be instantiable.

Example: class Circle : public Shape { public: void draw() override { // specific drawing code } }; Now, Circle objects can be created because 'draw' is implemented.

Result

Derived class objects can be created only if all pure virtual functions are implemented.

Knowing this prevents errors where you forget to implement required functions and wonder why objects can't be created.

5

Intermediate

Pure Virtual Functions with Implementation

Concept: Though rare, a pure virtual function can have a body in the base class, which derived classes can call.

Syntax example: class Base { public: virtual void func() = 0; // pure virtual }; void Base::func() { // base implementation } Derived classes must still override func(), but can call Base::func() if needed.

Result

Allows sharing common code while enforcing override.

This shows pure virtual functions are flexible and can provide default behavior while still requiring customization.

6

Advanced

Role in Polymorphism and Interfaces

🤔Before reading on: do you think pure virtual functions are necessary for polymorphism? Commit to your answer.

Concept: Pure virtual functions define interfaces that enable polymorphism by forcing derived classes to implement specific behaviors.

Using pure virtual functions, you create abstract base classes that act like interfaces. This allows writing code that works with any derived class through base pointers or references, calling overridden methods without knowing exact types.

Result

Flexible and extensible code that can handle new types without modification.

Understanding this clarifies why pure virtual functions are foundational for designing extensible software.

7

Expert

Common Pitfalls and Compiler Behavior

🤔Before reading on: do you think a class with a pure virtual destructor must provide its destructor implementation? Commit to your answer.

Concept: Pure virtual destructors must have an implementation, and forgetting this causes linker errors.

Example: class Base { public: virtual ~Base() = 0; // pure virtual destructor }; Base::~Base() { /* cleanup code */ } This ensures proper cleanup when deleting derived objects via base pointers.

Result

Correct destruction order and no linker errors.

Knowing this prevents subtle bugs and build errors related to object destruction in inheritance hierarchies.

Under the Hood

When a class has a pure virtual function, the compiler marks it as abstract and prevents direct instantiation. Internally, the compiler creates a virtual table (vtable) for the class, which holds pointers to virtual functions. For pure virtual functions, the vtable entry points to a special stub that triggers a runtime error if called without override. Derived classes must provide their own function pointers in the vtable. This mechanism enables runtime polymorphism by resolving function calls dynamically.

Why designed this way?

Pure virtual functions were introduced to enforce interface contracts in C++ without language-level interfaces like in some other languages. This design allows flexibility by combining abstract behavior with concrete implementations in the same class hierarchy. The '= 0' syntax is concise and clear, signaling to both compiler and programmer that the function is intentionally left unimplemented. Alternatives like separate interface classes were less flexible and more verbose.

Class with Pure Virtual Function
┌─────────────────────────────┐
│         Base Class          │
│ +-------------------------+ │
│ | virtual void func() = 0; | │
│ +-------------------------+ │
│           vtable             │
│  ┌───────────────────────┐  │
│  │ func -> pure virtual  │  │
│  └───────────────────────┘  │
└─────────────┬───────────────┘
              │
              ▼
Derived Class
┌─────────────────────────────┐
│       Derived Class          │
│ +-------------------------+ │
│ | void func() override {}  | │
│ +-------------------------+ │
│           vtable             │
│  ┌───────────────────────┐  │
│  │ func -> Derived::func │  │
│  └───────────────────────┘  │
└─────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Can you instantiate a class with a pure virtual function? Commit to yes or no.

Common Belief: You can create objects of a class with pure virtual functions as long as you don't call those functions.

Reality: Classes with pure virtual functions are abstract and cannot be instantiated at all.

Why it matters: Trying to instantiate such classes leads to compile-time errors, confusing beginners who expect partial functionality.

Quick: Do pure virtual functions always have no implementation? Commit to yes or no.

Common Belief: Pure virtual functions cannot have any implementation in the base class.

Reality: Pure virtual functions can have implementations, but derived classes must still override them.

Why it matters: Knowing this allows sharing common code and avoids duplication while enforcing overrides.

Quick: Does a derived class become concrete if it implements only some pure virtual functions? Commit to yes or no.

Common Belief: Implementing some pure virtual functions is enough to create objects of the derived class.

Reality: All pure virtual functions must be implemented; otherwise, the derived class remains abstract.

Why it matters: Partial implementation leads to confusing errors and prevents object creation.

Quick: Must pure virtual destructors have a body? Commit to yes or no.

Common Belief: Pure virtual destructors do not need an implementation because they are abstract.

Reality: Pure virtual destructors must have an implementation to ensure proper cleanup.

Why it matters: Omitting the destructor body causes linker errors and resource leaks.

Expert Zone

1

A pure virtual function with an implementation can be called explicitly by derived classes to reuse code, blending abstraction with shared behavior.

2

Abstract classes with only pure virtual functions act like interfaces, but C++ allows mixing concrete and abstract methods in the same class, offering design flexibility.

3

The compiler generates a special 'pure virtual function call' handler that triggers runtime errors if a pure virtual function is called without override, helping catch design mistakes.

When NOT to use

Avoid pure virtual functions when you want to provide a default behavior that derived classes can optionally override; use regular virtual functions instead. Also, if you do not need polymorphism or interface enforcement, simple inheritance or composition might be better.

Production Patterns

In real-world systems, pure virtual functions define interfaces for plugins, device drivers, or GUI components, enabling modular design. They are used in frameworks to enforce contracts while allowing diverse implementations. Often combined with smart pointers and factory patterns to manage object lifetimes and creation.

Connections

Interfaces in Java

Pure virtual functions in C++ serve a similar role to interfaces in Java by defining methods that must be implemented.

Understanding pure virtual functions helps grasp how different languages enforce contracts and polymorphism.

Design by Contract (Software Engineering)

Pure virtual functions enforce a contract that derived classes must fulfill.

This connection shows how programming language features support broader software design principles.

Abstract Algebra (Mathematics)

Abstract classes with pure virtual functions resemble abstract algebraic structures that define operations without specifying implementation.

Recognizing this analogy deepens understanding of abstraction as a universal concept beyond programming.

Common Pitfalls

#1 Trying to instantiate an abstract class directly.

Wrong approach:

Shape s; // Error: cannot instantiate abstract class

Correct approach:

Circle c; // Circle implements all pure virtual functions, so this works

Root cause:

Misunderstanding that abstract classes cannot create objects because they have incomplete functions.

#2 Forgetting to implement all pure virtual functions in derived class.

Wrong approach:

class Square : public Shape { }; // No draw() implementation

Correct approach:

class Square : public Shape { void draw() override { /* code */ } };

Root cause:

Not realizing that missing implementations keep the derived class abstract.

#3 Declaring a pure virtual destructor without providing a body.

Wrong approach:

class Base { virtual ~Base() = 0; }; // No destructor body

Correct approach:

class Base { virtual ~Base() = 0; };
Base::~Base() { /* cleanup */ }

Root cause:

Not knowing that pure virtual destructors still need definitions for proper cleanup.

Key Takeaways

Pure virtual functions declare methods without implementation, making a class abstract and uninstantiable.

Derived classes must implement all pure virtual functions to become concrete and create objects.

Pure virtual functions enable polymorphism by defining interfaces that derived classes must follow.

They can have implementations in the base class, allowing shared code while enforcing overrides.

Proper use of pure virtual destructors is essential for safe object cleanup in inheritance hierarchies.