Runtime polymorphism in C++ - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of virtual function call through base pointer

What is the output of this C++ code when run?

C++

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void sound() { cout << "Animal sound" << endl; }
};

class Dog : public Animal {
public:
    void sound() override { cout << "Bark" << endl; }
};

int main() {
    Animal* a = new Dog();
    a->sound();
    delete a;
    return 0;
}

A Animal sound

B Bark

C Compilation error

D Runtime error

💡 Hint

Think about which version of the function is called when using a base class pointer to a derived object.

Because the function sound() is virtual, the call a->sound() uses the derived class Dog's override, printing "Bark".

❓ Predict Output

intermediate

Output of non-virtual function call through base pointer

What will this C++ program print when executed?

C++

#include <iostream>
using namespace std;

class Base {
public:
    void show() { cout << "Base show" << endl; }
};

class Derived : public Base {
public:
    void show() { cout << "Derived show" << endl; }
};

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

A Compilation error

B Derived show

C Base show

D Runtime error

💡 Hint

Is the function show() declared virtual? How does that affect which function is called?

Since show() is not virtual, the call b->show() calls Base's version, printing "Base show".

🔧 Debug

advanced

Identify the runtime error in polymorphic code

This code compiles but causes a runtime error. What is the cause?

C++

#include <iostream>
using namespace std;

class Base {
public:
    virtual void display() { cout << "Base display" << endl; }
    ~Base() { cout << "Base destructor" << endl; }
};

class Derived : public Base {
public:
    void display() override { cout << "Derived display" << endl; }
    ~Derived() { cout << "Derived destructor" << endl; }
};

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

A No runtime error occurs

B Virtual function display() is not overridden correctly

C Base destructor is virtual causing double delete

D Derived destructor is not called causing resource leak

💡 Hint

Check if the destructor in Base is virtual and how that affects deleting derived objects.

Base destructor is not virtual, so deleting Base* pointing to Derived object calls only Base destructor, skipping Derived destructor and causing resource leaks.

📝 Syntax

advanced

Identify the syntax error in polymorphic class declaration

Which option contains a syntax error in this polymorphic class code?

C++

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

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

A class Triangle : public Shape { public: void draw() override; };

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

C class Square : public Shape { public: void draw() { cout << "Square" << endl; } };

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

💡 Hint

Check if the function declared with override has a body or is defined outside the class.

Option A declares draw() with override but does not provide a function body or definition, causing a linker error (not a syntax error strictly, but incomplete definition).

🚀 Application

expert

Determine the number of objects created and destructed

Consider this C++ program using runtime polymorphism. How many times are constructors and destructors called in total?

C++

#include <iostream>
using namespace std;

class Base {
public:
    Base() { cout << "Base constructor" << endl; }
    virtual ~Base() { cout << "Base destructor" << endl; }
};

class Derived : public Base {
public:
    Derived() { cout << "Derived constructor" << endl; }
    ~Derived() { cout << "Derived destructor" << endl; }
};

int main() {
    Base* arr[3];
    arr[0] = new Base();
    arr[1] = new Derived();
    arr[2] = new Derived();

    for (int i = 0; i < 3; i++) {
        delete arr[i];
    }
    return 0;
}

A 5 constructors and 5 destructors called

B 6 constructors and 3 destructors called

C 3 constructors and 3 destructors called

D 6 constructors and 6 destructors called

💡 Hint

Remember each Derived object calls Base constructor first. Also destructors are called in reverse order.

Each Derived object calls Base constructor then Derived constructor (2 constructors per Derived). There are 2 Derived and 1 Base objects: total 3 Base constructors + 2 Derived constructors = 5 constructors. Destructors called similarly: Derived destructors for 2 Derived objects + Base destructors for all 3 objects = 5 destructors total. So total constructors and destructors are 5 each.