Runtime polymorphism in C++ - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a virtual function in the base class.

C++

class Base {
public:
    virtual void [1]() {
        std::cout << "Base function" << std::endl;
    }
};

Drag options to blanks, or click blank then click option'

Adisplay

Bshow

Cprint

Doutput

Attempts:

3 left

💡 Hint

Common Mistakes

Using a function name not matching the derived class function.

Forgetting to mark the function as virtual.

The function name display is used as the virtual function in the base class.

2fill in blank

medium

Complete the code to override the virtual function in the derived class.

C++

class Derived : public Base {
public:
    void [1]() override {
        std::cout << "Derived function" << std::endl;
    }
};

Drag options to blanks, or click blank then click option'

Aprint

Bshow

Cdisplay

Doutput

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different function name than the base class.

Omitting the override keyword.

The derived class overrides the display function declared virtual in the base class.

3fill in blank

hard

Fix the error in the code to call the derived class function through a base class pointer.

C++

Base* ptr = new Derived();
ptr->[1]();

Drag options to blanks, or click blank then click option'

Ashow

Bdisplay

Cprint

Doutput

Attempts:

3 left

💡 Hint

Common Mistakes

Calling a function name not declared in the base class.

Not using a pointer or reference to base class.

Calling display on the base class pointer invokes the derived class version due to virtual function.

4fill in blank

hard

Fill both blanks to define a base class pointer and call the virtual function.

C++

Base* [1] = new [2]();
[1]->display();

Drag options to blanks, or click blank then click option'

Aptr

BDerived

CBase

Dobj

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for pointer variable.

Creating an object of base class instead of derived.

The pointer ptr of type Base* points to a new Derived object to demonstrate runtime polymorphism.

5fill in blank

hard

Fill all three blanks to create a vector of base class pointers and call the virtual function on each.

C++

#include <vector>
#include <iostream>

std::vector<Base*> [1];
[1].push_back(new [2]());
[1].push_back(new [3]());

for (auto ptr : [1]) {
    ptr->display();
}

Drag options to blanks, or click blank then click option'

Aobjects

BDerived

CBase

Ditems

Attempts:

3 left

💡 Hint

Common Mistakes

Using different vector names in different places.

Adding base class objects instead of derived class objects.

The vector named objects holds pointers to Derived objects. Calling display on each pointer demonstrates runtime polymorphism.

Practice

1. What is the main purpose of virtual functions in C++ runtime polymorphism?

easy

A. To allocate memory for objects dynamically

B. To make functions run faster by avoiding function calls

C. To prevent any function from being overridden in derived classes

D. To allow derived classes to override base class methods and decide at runtime which method to call

Solution

1. Step 1: Understand virtual functions role

   Virtual functions allow a base class to declare a function that derived classes can override.

2. Step 2: Explain runtime decision

   At runtime, the program decides which overridden function to call based on the actual object type.

3. Final Answer:

   To allow derived classes to override base class methods and decide at runtime which method to call -> Option D

4. Quick Check:

   Virtual functions enable runtime method selection [OK]

Hint: Virtual means choose function at runtime, not compile time [OK]

Common Mistakes:

• Thinking virtual speeds up function calls
• Believing virtual prevents overriding
• Confusing virtual with memory allocation

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

easy

A. void display() virtual;

B. void virtual display();

C. virtual void display();

D. virtual: void display();

Solution

1. Step 1: Recall virtual function syntax

   The keyword virtual comes before the return type in the function declaration.

2. Step 2: Match correct syntax

   virtual void display(); correctly places virtual before void display();

3. Final Answer:

   virtual void display(); -> Option C

4. Quick Check:

   Virtual keyword precedes return type [OK]

Hint: Virtual always goes before return type in declaration [OK]

Common Mistakes:

• Placing virtual after function name
• Using virtual as a label or modifier incorrectly
• Missing semicolon after declaration

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

class Base {
public:
    virtual void show() { std::cout << "Base"; }
};
class Derived : public Base {
public:
    void show() override { std::cout << "Derived"; }
};
int main() {
    Base* ptr = new Derived();
    ptr->show();
    delete ptr;
    return 0;
}

medium

A. Derived

B. Base

C. Compilation error

D. Runtime error

Solution

1. Step 1: Identify virtual function usage

   The show() function in Base is virtual and overridden in Derived.

2. Step 2: Understand pointer type and object type

   The pointer is of type Base* but points to a Derived object, so the overridden show() in Derived is called at runtime.

3. Final Answer:

   Derived -> Option A

4. Quick Check:

   Virtual function calls derived version [OK]

Hint: Virtual functions call derived method via base pointer [OK]

Common Mistakes:

• Expecting base class method output
• Confusing pointer type with object type
• Ignoring virtual keyword effect

4. Identify the error in the following code snippet related to runtime polymorphism:

class Animal {
public:
    void sound() { std::cout << "Animal sound"; }
};
class Dog : public Animal {
public:
    void sound() { std::cout << "Bark"; }
};
int main() {
    Animal* a = new Dog();
    a->sound();
    delete a;
    return 0;
}

medium

A. Incorrect pointer type declaration

B. Missing virtual keyword in base class function

C. Derived class function should be static

D. Memory leak due to missing delete

Solution

1. Step 1: Check base class function declaration

   The base class function sound() is not declared virtual, so no runtime polymorphism occurs.

2. Step 2: Effect on function call

   Because sound() is not virtual, calling a->sound() calls the base class version, not the derived one.

3. Final Answer:

   Missing virtual keyword in base class function -> Option B

4. Quick Check:

   Virtual needed for runtime polymorphism [OK]

Hint: Base function must be virtual for polymorphism [OK]

Common Mistakes:

• Assuming override works without virtual
• Thinking pointer type causes error
• Ignoring virtual keyword importance

5. Given the classes below, what will be the output when ptr->identify() is called?

class Shape {
public:
    virtual void identify() { std::cout << "Shape"; }
};
class Circle : public Shape {
public:
    void identify() override { std::cout << "Circle"; }
};
class ColoredCircle : public Circle {
public:
    void identify() override { std::cout << "Colored Circle"; }
};
int main() {
    Shape* ptr = new ColoredCircle();
    ptr->identify();
    delete ptr;
    return 0;
}

hard

A. Colored Circle

B. Circle

C. Shape

D. Compilation error due to multiple overrides

Solution

1. Step 1: Trace virtual function overrides

   identify() is virtual in Shape, overridden in Circle, and again in ColoredCircle.

2. Step 2: Determine actual object type at runtime

   The pointer ptr is of type Shape* but points to a ColoredCircle object, so the most derived override runs.

3. Final Answer:

   Colored Circle -> Option A

4. Quick Check:

   Most derived override called at runtime [OK]

Hint: Runtime calls most derived override in inheritance chain [OK]

Common Mistakes:

• Expecting base or intermediate class output
• Thinking multiple overrides cause errors
• Ignoring virtual override chain