Interface-like behavior in C++ - Step-by-Step Execution

Concept Flow - Interface-like behavior

Define Abstract Class

↓

Declare Pure Virtual Functions

↓

Create Derived Classes

↓

Override Pure Virtual Functions

↓

Use Base Class Pointer/Reference

↓

Call Overridden Functions at Runtime

This flow shows how an abstract class with pure virtual functions acts like an interface, forcing derived classes to implement specific methods, and how polymorphism allows calling these methods through base class pointers.

Execution Sample

C++

#include <iostream>

class IShape {
public:
  virtual void draw() = 0;
};

class Circle : public IShape {
public:
  void draw() override { std::cout << "Drawing Circle\n"; }
};

Defines an interface-like abstract class IShape with a pure virtual draw method, and a Circle class that implements draw.

Execution Table

Step	Action	Evaluation	Result
1	Create Circle object	Circle c;	Object c created
2	Assign base pointer	IShape* shape = &c;	Pointer shape points to c
3	Call draw via base pointer	shape->draw();	Calls Circle::draw(), prints 'Drawing Circle'
4	Attempt to instantiate IShape	IShape i;	Error: cannot instantiate abstract class
5	Exit	End of program	Program ends normally

💡 Cannot instantiate abstract class IShape; polymorphic call calls derived draw()

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
c (Circle object)	none	created	created	created	created
shape (IShape*)	nullptr	nullptr	points to c	points to c	points to c

Key Moments - 3 Insights

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

Because IShape has a pure virtual function (draw), it is abstract and cannot be instantiated. See execution_table step 4 where trying to create IShape causes an error.

How does calling draw() on shape call Circle's draw()?

The base pointer shape points to a Circle object. The virtual function mechanism calls the overridden Circle::draw() at runtime, as shown in execution_table step 3.

What happens if Circle does not override draw()?

Circle would also be abstract and cannot be instantiated. The compiler enforces overriding pure virtual functions.

Visual Quiz - 3 Questions

Look at the execution_table, what does step 3's call to shape->draw() output?

A Drawing Circle

B Drawing Shape

C Compilation error

D No output

💡 Hint

See execution_table row 3 under Result column

At which step does the program show an error for trying to instantiate an abstract class?

A Step 1

B Step 4

C Step 2

D Step 5

💡 Hint

Check execution_table row 4 under Evaluation and Result

If we remove the override of draw() in Circle, what changes in variable_tracker?

A shape points to base class instead

B shape pointer becomes nullptr

C Circle object cannot be created, so no 'created' state

D No change in variable_tracker

💡 Hint

Refer to key_moments about overriding pure virtual functions

Concept Snapshot

Interface-like behavior in C++:
- Use abstract class with pure virtual functions (e.g., virtual void f() = 0;)
- Derived classes must override these functions
- Cannot instantiate abstract class
- Use base class pointers to call overridden methods polymorphically
- Enables interface-like design without explicit 'interface' keyword

Full Transcript

This example shows how C++ uses abstract classes with pure virtual functions to create interface-like behavior. The abstract class IShape declares a pure virtual function draw(), making it impossible to create IShape objects directly. The Circle class inherits from IShape and overrides draw(), providing its own implementation. We create a Circle object and assign its address to a base class pointer of type IShape*. When we call draw() through this pointer, the Circle's version runs because of virtual function dispatch. Attempting to instantiate IShape directly causes a compile-time error. This pattern enforces that derived classes implement required methods, mimicking interfaces in other languages.

Practice

1. What is the main purpose of an interface-like class in C++?

easy

A. To store data members for derived classes

B. To provide full function implementations for reuse

C. To define functions that derived classes must implement

D. To create objects directly without inheritance

Solution

1. Step 1: Understand interface concept

   Interfaces specify what functions a class must have but do not provide their code.

2. Step 2: Identify interface role in C++

   In C++, interfaces are created using pure virtual functions that derived classes must implement.

3. Final Answer:

   To define functions that derived classes must implement -> Option C

4. Quick Check:

   Interface = function declarations only [OK]

Hint: Interfaces declare required functions without code [OK]

Common Mistakes:

• Thinking interfaces provide function code
• Assuming interfaces hold data members
• Believing interfaces can be instantiated

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

easy

A. virtual void func() = 0;

B. virtual void func();

C. void func() override;

D. virtual void func() = 1;

Solution

1. Step 1: Recall pure virtual function syntax

   Pure virtual functions are declared with '= 0' after the function signature.

2. Step 2: Check options for correct syntax

   virtual void func() = 0; uses '= 0' correctly, others do not match pure virtual syntax.

3. Final Answer:

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

4. Quick Check:

   Pure virtual = '= 0' [OK]

Hint: Pure virtual functions end with '= 0;' [OK]

Common Mistakes:

• Using '= 1' instead of '= 0'
• Omitting 'virtual' keyword
• Confusing override with pure virtual

3. Consider the following code:

class IShape {
public:
    virtual double area() const = 0;
};

class Circle : public IShape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override { return 3.14 * radius * radius; }
};

int main() {
    Circle c(2);
    std::cout << c.area();
    return 0;
}

What is the output of this program?

medium

A. 4

B. Compilation error

C. 3.14

D. 12.56

Solution

1. Step 1: Calculate area of circle with radius 2

   Area = π * r² = 3.14 * 2 * 2 = 12.56

2. Step 2: Confirm code compiles and runs correctly

   Circle implements pure virtual function area(), so no error; output is area value.

3. Final Answer:

   12.56 -> Option D

4. Quick Check:

   Area = 3.14 * 4 = 12.56 [OK]

Hint: Calculate area formula carefully [OK]

Common Mistakes:

• Forgetting to implement pure virtual function
• Using wrong radius value
• Expecting compilation error

4. What is wrong with this code snippet?

class IAnimal {
public:
    virtual void speak() = 0;
};

class Dog : public IAnimal {
public:
    void speak() { std::cout << "Woof"; }
};

int main() {
    IAnimal a;
    a.speak();
    return 0;
}

medium

A. Missing override keyword in Dog::speak()

B. Cannot create object of abstract class IAnimal

C. speak() should return a value

D. Dog class must be abstract

Solution

1. Step 1: Identify abstract class usage

   IAnimal has a pure virtual function, so it is abstract and cannot be instantiated.

2. Step 2: Check main() for object creation

   Code tries to create IAnimal a; which is illegal and causes compilation error.

3. Final Answer:

   Cannot create object of abstract class IAnimal -> Option B

4. Quick Check:

   Abstract class objects cannot be created [OK]

Hint: Abstract classes cannot be instantiated [OK]

Common Mistakes:

• Ignoring abstract class instantiation rules
• Thinking override keyword is mandatory
• Assuming pure virtual functions must return values

5. You want to create an interface-like class IPrinter with a pure virtual function print(). Then create two classes ConsolePrinter and FilePrinter that implement print(). Which of the following code snippets correctly demonstrates this?

hard

A. class IPrinter {
public:
virtual void print() = 0;
};

class ConsolePrinter : public IPrinter {
public:
void print() override { std::cout << "Console output"; }
};

class FilePrinter : public IPrinter {
public:
void print() override { /* write to file */ }
};

B. class IPrinter {
public:
void print() { }
};

class ConsolePrinter : public IPrinter {
public:
void print() { std::cout << "Console output"; }
};

C. class IPrinter {
public:
virtual void print();
};

class ConsolePrinter : public IPrinter {
};

D. class IPrinter {
public:
virtual void print() = 1;
};

Solution

1. Step 1: Define interface with pure virtual function

   IPrinter declares print() as pure virtual with '= 0', making it an interface.

2. Step 2: Implement print() in derived classes

   ConsolePrinter and FilePrinter override print() with their own code, fulfilling interface contract.

3. Final Answer:

   Code snippet D correctly defines interface and implementations -> Option A

4. Quick Check:

   Pure virtual = 0 + override implementations [OK]

Hint: Use '= 0' for pure virtual and override in derived [OK]

Common Mistakes:

• Using '= 1' instead of '= 0' for pure virtual
• Not implementing pure virtual functions in derived classes
• Defining interface functions with bodies