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.

Practice

1. What is the main purpose of a pure virtual function in C++?

easy

A. To force derived classes to implement the function

B. To allow creating objects of the base class

C. To provide a default implementation in the base class

D. To make the function private

Solution

1. Step 1: Understand pure virtual function role

   A pure virtual function is declared with = 0 and has no body in the base class.

2. Step 2: Effect on derived classes

   Derived classes must provide their own implementation of this function, or they become abstract too.

3. Final Answer:

   To force derived classes to implement the function -> Option A

4. Quick Check:

   Pure virtual function = forces implementation [OK]

Hint: Pure virtual means must override in child class [OK]

Common Mistakes:

• Thinking pure virtual allows base class objects
• Assuming pure virtual provides default code
• Confusing pure virtual with private functions

2. Which of the following is the correct syntax to declare a pure virtual function named draw in a class?

easy

A. void draw() = 0;

B. virtual void draw() = 0;

C. virtual void draw() {}

D. void virtual draw() = 0;

Solution

1. Step 1: Recall pure virtual function syntax

   Pure virtual functions use the keyword virtual and end with = 0;.

2. Step 2: Check each option

   virtual void draw() = 0; matches the correct syntax: virtual void draw() = 0;. Others have wrong order, missing virtual, or provide a body.

3. Final Answer:

   virtual void draw() = 0; -> Option B

4. Quick Check:

   Syntax = virtual + = 0 [OK]

Hint: Pure virtual = virtual + = 0 at end [OK]

Common Mistakes:

• Placing 'virtual' after return type incorrectly
• Adding function body {} for pure virtual
• Omitting 'virtual' keyword

3. What will be the output of the following code?

#include <iostream>
class Shape {
public:
  virtual void draw() = 0;
};

class Circle : public Shape {
public:
  void draw() { std::cout << "Circle drawn" << std::endl; }
};

int main() {
  Circle c;
  c.draw();
  return 0;
}

medium

A. No output

B. Compilation error: cannot instantiate abstract class

C. Circle drawn

D. Runtime error

Solution

1. Step 1: Analyze class Shape

   Shape has a pure virtual function draw(), so Shape is abstract and cannot be instantiated.

2. Step 2: Analyze class Circle

   Circle overrides draw() with its own implementation, so Circle is concrete and can be instantiated.

3. Step 3: Check main function

   Circle object c is created and c.draw() prints "Circle drawn".

4. Final Answer:

   Circle drawn -> Option C

5. Quick Check:

   Derived class implements pure virtual = prints output [OK]

Hint: Derived class must implement to create objects [OK]

Common Mistakes:

• Trying to instantiate abstract base class
• Forgetting to override pure virtual function
• Expecting no output due to pure virtual

4. Identify the error in this code snippet:

class Animal {
public:
  virtual void sound() = 0;
};

class Dog : public Animal {
};

int main() {
  Dog d;
  d.sound();
  return 0;
}

medium

A. No error, code runs fine

B. Animal class should not have pure virtual functions

C. Dog object cannot be created because main is missing

D. Dog class does not implement pure virtual function sound()

Solution

1. Step 1: Check pure virtual function in Animal

   Animal declares sound() as pure virtual, so Animal is abstract.

2. Step 2: Check Dog class implementation

   Dog inherits Animal but does not implement sound(), so Dog remains abstract and cannot be instantiated.

3. Step 3: Analyze main function

   Trying to create Dog object d causes compilation error because Dog is abstract.

4. Final Answer:

   Dog class does not implement pure virtual function sound() -> Option D

5. Quick Check:

   Abstract class must implement all pure virtual functions [OK]

Hint: Derived must implement all pure virtual functions [OK]

Common Mistakes:

• Assuming base class cannot have pure virtual functions
• Thinking missing main causes error here
• Believing code runs without overriding pure virtual

5. Given the following classes, which statement is true?

#include <iostream>
class Base {
public:
  virtual void f() = 0;
  virtual void g() { std::cout << "Base g" << std::endl; }
};

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

int main() {
  Base* b = new Derived();
  b->f();
  b->g();
  delete b;
  return 0;
}

hard

A. Output is:
Derived f
Derived g

B. Output is:
Base f
Base g

C. Compilation error because Base has pure virtual function

D. Runtime error due to calling pure virtual function

Solution

1. Step 1: Understand Base class

   Base has pure virtual f() and virtual g() with implementation.

2. Step 2: Analyze Derived class

   Derived overrides both f() and g() with its own implementations.

3. Step 3: Check main function calls

   Pointer b of type Base* points to Derived object. Virtual calls invoke Derived versions of f() and g().

4. Final Answer:

   Output is: Derived f Derived g -> Option A

5. Quick Check:

   Virtual functions call derived overrides [OK]

Hint: Virtual calls use derived class methods [OK]

Common Mistakes:

• Expecting base class methods to run
• Thinking pure virtual causes compile error here
• Confusing pure virtual with runtime error