Abstract classes in C++ - Step-by-Step Execution

Concept Flow - Abstract classes

Define abstract class with pure virtual function

↓

Cannot create object of abstract class

↓

Create derived class implementing pure virtual function

↓

Create object of derived class

↓

Call implemented function via base pointer/reference

↓

Run program

Shows how an abstract class defines a contract with pure virtual functions, which derived classes must implement 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 class Shape with a pure virtual draw method, and a Circle class that implements draw.

Execution Table

Step	Action	Evaluation	Result
1	Define class Shape with pure virtual draw()	Shape is abstract	Cannot instantiate Shape
2	Define class Circle derived from Shape	Circle overrides draw()	Circle is concrete
3	Try to create Shape object	Error	Compilation error: cannot instantiate abstract class
4	Create Circle object	Allowed	Circle object created
5	Call draw() on Circle object	Calls Circle::draw()	Circle's draw() runs
6	Assign Circle object to Shape pointer	Allowed	Pointer to base holds derived object
7	Call draw() via Shape pointer	Calls Circle::draw() (polymorphism)	Circle's draw() runs
8	End of program		Program ends successfully

💡 Program ends after calling draw() on Circle object via base pointer

Variable Tracker

Variable	Start	After Step 4	After Step 6	Final
Shape object	None (abstract)	N/A (cannot create)	N/A	N/A
Circle object	None	Created	Created	Exists
Shape pointer	None	None	Points to Circle object	Points to Circle object

Key Moments - 3 Insights

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

Because Shape has a pure virtual function (draw), it is abstract and incomplete. See execution_table step 3 where trying to create Shape causes a compilation error.

How does calling draw() via a Shape pointer call the Circle's draw()?

Because draw() is virtual, the call is resolved at runtime to the derived class's implementation. See execution_table step 7 where Shape pointer calls Circle::draw().

What happens if Circle does not implement draw()?

Circle would also be abstract and cannot be instantiated. The compiler enforces implementation of all pure virtual functions.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 3?

A Compilation error because Shape is abstract

B An object of Shape is successfully created

C Circle object is created

D draw() is called on Shape object

💡 Hint

Check the 'Result' column at step 3 in execution_table

At which step does polymorphism allow calling Circle's draw() via a Shape pointer?

A Step 4

B Step 7

C Step 5

D Step 3

💡 Hint

Look for 'Call draw() via Shape pointer' in execution_table

If Circle did not implement draw(), what would happen?

A Shape would no longer be abstract

B Circle would be concrete and instantiable

C Circle would be abstract and cannot be instantiated

D Program would run without errors

💡 Hint

Refer to key_moments about implementation of pure virtual functions

Concept Snapshot

Abstract classes have at least one pure virtual function (e.g., virtual void f() = 0;).
They cannot be instantiated directly.
Derived classes must implement all pure virtual functions.
Objects of derived classes can be created and used polymorphically via base pointers.
This enforces a contract for subclasses to follow.

Full Transcript

An abstract class in C++ is a class that has at least one pure virtual function, declared with = 0. This means the class cannot be instantiated directly because it is incomplete. Derived classes must provide implementations for all pure virtual functions to become concrete. Once implemented, objects of the derived class can be created. Using a base class pointer to refer to a derived object allows polymorphic calls to the overridden functions. This mechanism enforces a design contract and enables flexible code reuse and extension.

Practice

1. What is true about an abstract class in C++?

easy

A. It can be instantiated like any other class.

B. It cannot be instantiated directly.

C. It must have no member functions.

D. It cannot have any data members.

Solution

1. Step 1: Understand abstract class instantiation rules

   Abstract classes have at least one pure virtual function, so they cannot create objects directly.

2. Step 2: Check other options

   The other options are incorrect because abstract classes can have member functions and data members.

3. Final Answer:

   It cannot be instantiated directly. -> Option B

4. Quick Check:

   Abstract class = no direct objects [OK]

Hint: Abstract classes always have pure virtual functions [OK]

Common Mistakes:

• Thinking abstract classes can create objects
• Believing abstract classes cannot have data members
• Confusing abstract classes with interfaces

2. Which of the following is the correct way to declare a pure virtual function in a C++ abstract class?

easy

A. virtual void func() = 0;

B. void func() = 0;

C. virtual void func();

D. void func() {};

Solution

1. Step 1: Recall pure virtual function syntax

   Pure virtual functions are declared with 'virtual' keyword and '= 0' at the end.

2. Step 2: Analyze options

   virtual void func() = 0; matches the correct syntax. void func() = 0; misses 'virtual'. virtual void func(); is a normal virtual function. void func() {}; is a normal function with a body.

3. Final Answer:

   virtual void func() = 0; -> Option A

4. Quick Check:

   Pure virtual = virtual + '= 0' [OK]

Hint: Pure virtual always ends with '= 0;' [OK]

Common Mistakes:

• Omitting 'virtual' keyword
• Adding function body to pure virtual
• Confusing normal virtual with pure virtual

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

#include <iostream>
class Base {
public:
    virtual void show() = 0;
};
class Derived : public Base {
public:
    void show() { std::cout << "Hello"; }
};
int main() {
    Derived d;
    d.show();
    return 0;
}

medium

A. No output

B. Compilation error

C. Hello

D. Runtime error

Solution

1. Step 1: Check abstract class and derived implementation

   Base has a pure virtual function 'show'. Derived overrides it with a concrete implementation.

2. Step 2: Analyze main function output

   Derived object 'd' calls 'show()', which prints "Hello".

3. Final Answer:

   Hello -> Option C

4. Quick Check:

   Derived implements pure virtual, so prints output [OK]

Hint: Derived must implement pure virtual to avoid errors [OK]

Common Mistakes:

• Expecting compilation error without implementation
• Thinking pure virtual functions run by themselves
• Confusing output with no output

4. Identify the error in this code snippet:

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

class Concrete : public Abstract {
public:
    void display() { std::cout << "Hi"; }
};

int main() {
    Abstract a;
    Concrete c;
    c.display();
    return 0;
}

medium

A. Cannot instantiate abstract class 'Abstract' directly.

B. Missing implementation of display() in Concrete.

C. Syntax error in class declaration.

D. No error, code runs fine.

Solution

1. Step 1: Check instantiation of abstract class

   Abstract class 'Abstract' has a pure virtual function, so cannot create object 'a'.

2. Step 2: Verify other parts

   Concrete implements display(), so no error there. Syntax is correct.

3. Final Answer:

   Cannot instantiate abstract class 'Abstract' directly. -> Option A

4. Quick Check:

   Abstract objects not allowed [OK]

Hint: Never create objects of abstract classes [OK]

Common Mistakes:

• Trying to instantiate abstract class
• Ignoring pure virtual function rules
• Assuming implementation missing in derived

5. You want to design a shape system where every shape must provide its area calculation. Which is the best way to enforce this using abstract classes in C++?

hard

A. Create a class Shape with no functions and add area() only in derived classes.

B. Create a class Shape with a normal function double area() that returns 0, and override it in derived classes.

C. Create a class Shape with a virtual function double area() with empty body.

D. Create an abstract class Shape with a pure virtual function double area() = 0; and derive specific shapes implementing area().

Solution

1. Step 1: Understand requirement for enforcing area() implementation

   Using a pure virtual function in an abstract class forces all derived classes to implement area().

2. Step 2: Evaluate options

   Create an abstract class Shape with a pure virtual function double area() = 0; and derive specific shapes implementing area(). uses pure virtual function, which is the best way. Create a class Shape with a normal function double area() that returns 0, and override it in derived classes. returns 0 by default, which may hide missing implementations. Create a class Shape with no functions and add area() only in derived classes. does not enforce area() in base. Create a class Shape with a virtual function double area() with empty body. has virtual but not pure, so no enforcement.

3. Final Answer:

   Create an abstract class Shape with a pure virtual function double area() = 0; and derive specific shapes implementing area(). -> Option D

4. Quick Check:

   Pure virtual enforces implementation [OK]

Hint: Use pure virtual to force derived class methods [OK]

Common Mistakes:

• Using normal virtual instead of pure virtual
• Not enforcing method in base class
• Returning default values hiding missing overrides