Virtual functions 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?

C++

#include <iostream>
using namespace std;

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

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

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

A Compilation error

B Base show

C Runtime error

D Derived show

💡 Hint

Remember how virtual functions behave when called through a base class pointer.

Because show() is virtual, the call ptr->show() invokes Derived's version, printing "Derived show".

❓ Predict Output

intermediate

Output when virtual function is not overridden

What will this program print?

C++

#include <iostream>
using namespace std;

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

class Dog : public Animal {
    // No override of speak()
};

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

A Animal speaks

B Compilation error

C Dog speaks

D Runtime error

💡 Hint

If a derived class does not override a virtual function, which version is called?

Since Dog does not override speak(), the base class Animal's speak() is called, printing "Animal speaks".

🔧 Debug

advanced

Identify the error in virtual destructor usage

What error will this code produce when compiled or run?

C++

#include <iostream>
using namespace std;

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

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

int main() {
    Base* ptr = new Derived();
    delete ptr;
    return 0;
}

A Both Derived and Base destructors are called

B Only Base destructor is called, Derived destructor is skipped

C Compilation error due to missing virtual keyword

D Runtime crash due to invalid delete

💡 Hint

Think about what happens if the base class destructor is not virtual and you delete a derived object through a base pointer.

Because Base's destructor is not virtual, deleting a Derived object through a Base pointer calls only Base's destructor, skipping Derived's destructor, which can cause resource leaks.

📝 Syntax

advanced

Which option causes a compilation error?

Given the following class, which option will cause a compilation error?

C++

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

A class Square : public Shape {};

B class Rectangle : public Shape { void draw() override { /* code */ } };

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

D class Circle : public Shape { void draw() override { /* code */ } };

💡 Hint

What happens if a class inherits a pure virtual function but does not override it?

Square does not override the pure virtual function draw(), so it remains abstract and cannot be instantiated, causing a compilation error if instantiated.

🚀 Application

expert

Determine the number of virtual function calls

How many times is the virtual function 'action' called in this program?

C++

#include <iostream>
using namespace std;

class A {
public:
    virtual void action() { cout << "A"; }
};

class B : public A {
public:
    void action() override { cout << "B"; }
};

class C : public B {
public:
    void action() override { cout << "C"; }
};

int main() {
    A* arr[3];
    arr[0] = new A();
    arr[1] = new B();
    arr[2] = new C();

    for (int i = 0; i < 3; ++i) {
        arr[i]->action();
    }

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

A 6

B 1

C 3

D 0

💡 Hint

Count how many times the loop calls the virtual function.

The loop calls action() exactly 3 times, once for each pointer in the array. Each call is virtual and calls the correct overridden version.

Practice

1. What is the main purpose of declaring a function as virtual in a C++ base class?

easy

A. To allow derived classes to override the function and enable runtime polymorphism

B. To make the function inline for faster execution

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

D. To make the function static and shared among all objects

Solution

1. Step 1: Understand virtual function role

   A virtual function in a base class allows derived classes to provide their own implementation that will be called at runtime.

2. Step 2: Recognize runtime polymorphism

   This mechanism enables dynamic dispatch, meaning the program decides which function to call based on the actual object type, not the pointer type.

3. Final Answer:

   To allow derived classes to override the function and enable runtime polymorphism -> Option A

4. Quick Check:

   Virtual function = runtime polymorphism [OK]

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

Common Mistakes:

• Confusing virtual with inline functions
• Thinking virtual prevents overriding
• Assuming virtual makes function static

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

easy

A. virtual void display();

B. void virtual display();

C. virtual display void();

D. void display() virtual;

Solution

1. Step 1: Recall correct virtual function syntax

   The keyword virtual must come before the return type and function name.

2. Step 2: Check each option

   virtual void display(); correctly places virtual before void display();. Others have incorrect order or placement.

3. Final Answer:

   virtual void display(); -> Option A

4. Quick Check:

   virtual before return type = correct syntax [OK]

Hint: Put 'virtual' before return type in function declaration [OK]

Common Mistakes:

• Placing virtual after function name
• Mixing order of keywords
• Adding virtual at the end of declaration

3. Consider 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;
}

What is the output when this program runs?

medium

A. Base

B. Runtime error

C. Derived

D. Compilation error

Solution

1. Step 1: Analyze pointer and object types

   The pointer is of type Base* but points to a Derived object.

2. Step 2: Understand virtual function call

   Because show() is virtual, the Derived version is called at runtime, printing "Derived".

3. Final Answer:

   Derived -> Option C

4. Quick Check:

   Virtual function calls derived version [OK]

Hint: Virtual calls use actual object type, not pointer type [OK]

Common Mistakes:

• Assuming base class function runs
• Confusing override keyword effect
• Expecting compilation or runtime errors

4. Identify the error in the following code snippet:

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

medium

A. Derived class function cannot have the same name as base class function

B. No error, code is correct

C. Override keyword is not allowed in derived class

D. Base class function must be declared virtual to allow override

Solution

1. Step 1: Check base class function declaration

   The base class function display() is not declared virtual.

2. Step 2: Understand override keyword usage

   The override keyword requires the base function to be virtual; otherwise, it causes a compilation error.

3. Final Answer:

   Base class function must be declared virtual to allow override -> Option D

4. Quick Check:

   Override needs virtual base function [OK]

Hint: Base function must be virtual to use override in derived [OK]

Common Mistakes:

• Ignoring missing virtual in base
• Thinking override is optional
• Assuming same name always means override

5. Given the classes below, what will be the output of the program?

class Animal {
public:
    virtual void sound() { std::cout << "Animal sound "; }
};
class Dog : public Animal {
public:
    void sound() override { std::cout << "Bark "; }
};
class Cat : public Animal {
public:
    void sound() override { std::cout << "Meow "; }
};

int main() {
    Animal* animals[3];
    animals[0] = new Animal();
    animals[1] = new Dog();
    animals[2] = new Cat();

    for (int i = 0; i < 3; i++) {
        animals[i]->sound();
    }

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

hard

A. Animal sound Animal sound Animal sound

B. Animal sound Bark Meow

C. Bark Meow Animal sound

D. Compilation error due to array of pointers

Solution

1. Step 1: Analyze array of Animal pointers

   The array holds pointers to objects of types Animal, Dog, and Cat respectively.

2. Step 2: Understand virtual function calls in loop

   Calling sound() on each pointer calls the overridden version based on actual object type, printing "Animal sound ", "Bark ", and "Meow ".

3. Final Answer:

   Animal sound Bark Meow -> Option B

4. Quick Check:

   Virtual calls print actual object sounds [OK]

Hint: Virtual functions call derived versions in arrays of base pointers [OK]

Common Mistakes:

• Expecting base class sound for all
• Confusing array pointer syntax
• Assuming compilation error with polymorphism