Pure virtual functions in C++ - Step-by-Step Execution

Concept Flow - Pure virtual functions

Declare base class with pure virtual function

↓

Cannot instantiate base class

↓

Derive subclass and override pure virtual function

↓

Instantiate subclass object

↓

Call overridden function via base pointer/reference

↓

Execute subclass implementation

This flow shows how a pure virtual function makes a class abstract, requiring subclasses to provide their own implementation before objects can be created.

Execution Sample

C++

class Shape {
public:
  virtual void draw() = 0; // pure virtual
};

class Circle : public Shape {
public:
  void draw() override { /* draw circle */ }
};

Defines an abstract Shape class with a pure virtual draw function, then a Circle subclass that implements draw.

Execution Table

Step	Action	Evaluation	Result
1	Declare Shape with pure virtual draw()	draw() = 0	Shape is abstract, cannot create objects
2	Try to create Shape object	Shape s;	Error: cannot instantiate abstract class
3	Define Circle subclass overriding draw()	void draw() override	Circle is concrete, can create objects
4	Create Circle object	Circle c;	Object c created
5	Call draw() via Shape pointer	Shape* p = &c; p->draw();	Circle's draw() runs
6	Program ends	-	-

💡 Execution stops after Circle object is created and draw() is called; base class cannot be instantiated.

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
Shape object	none (abstract)	none (cannot create)	none	none
Circle object c	none	created	exists	exists
Shape* p	none	none	points to c	points to c

Key Moments - 3 Insights

Why can't we create an object of the base class Shape?

Because Shape has a pure virtual function (draw() = 0), it is abstract. As shown in execution_table step 2, trying to create Shape causes an error.

What happens when we call draw() through a Shape pointer to a Circle object?

The Circle's overridden draw() runs, as shown in execution_table step 5, demonstrating polymorphism.

Does the base class provide any implementation for the pure virtual function?

No, the pure virtual function has no implementation in the base class, forcing subclasses to implement it, as seen in step 3.

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 2 when trying to create a Shape object?

A Shape object is created successfully

B Shape object is created but draw() is not callable

C Compilation error because Shape is abstract

D Program crashes at runtime

💡 Hint

See execution_table row for step 2 describing the error when instantiating Shape.

At which step does the Circle object get created?

A Step 3

B Step 4

C Step 1

D Step 5

💡 Hint

Check execution_table row for step 4 where Circle object c is created.

If Circle did not override draw(), what would happen when calling p->draw() at step 5?

A Compile-time error due to missing override

B Base class draw() runs

C Circle's draw() runs anyway

D Program runs but does nothing

💡 Hint

Pure virtual functions require subclasses to override; see key_moments about subclass implementation.

Concept Snapshot

Pure virtual functions use syntax: virtual ReturnType func() = 0;
They make a class abstract (no objects allowed).
Derived classes must override them.
Allows polymorphism via base pointers.
Forces subclass to provide specific behavior.

Full Transcript

Pure virtual functions in C++ are declared by assigning 0 to a virtual function in a base class. This makes the class abstract, so you cannot create objects of it directly. Instead, you create subclasses that override the pure virtual function with their own implementation. Then you can create objects of these subclasses. When you call the function through a base class pointer or reference, the subclass's version runs. This is a key part of polymorphism in C++. The execution steps show declaring the abstract base class, failing to create its object, defining a subclass with the function implemented, creating its object, and calling the function through a base pointer.