Object creation and destruction flow in C++ - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of constructor and destructor calls

What is the output of this C++ program when executed?

C++

#include <iostream>
class Test {
public:
    Test() { std::cout << "Constructor\n"; }
    ~Test() { std::cout << "Destructor\n"; }
};

int main() {
    Test t1;
    {
        Test t2;
    }
    return 0;
}

A

Constructor
Constructor
Destructor
Destructor

B

Constructor
Destructor
Constructor
Destructor

C

Constructor
Destructor
Destructor
Constructor

D

Constructor
Constructor
Destructor

💡 Hint

Remember that destructors are called when objects go out of scope.

The first object t1 is created, printing 'Constructor'. Then inside the inner block, t2 is created, printing another 'Constructor'. When the inner block ends, t2 is destroyed, printing 'Destructor'. Finally, when main ends, t1 is destroyed, printing the last 'Destructor'.

🧠 Conceptual

intermediate

Order of constructor calls in inheritance

Given a base class and a derived class, in which order are constructors called when creating a derived class object?

A Only derived class constructor is called

B Derived class constructor first, then base class constructor

C Both constructors called simultaneously

D Base class constructor first, then derived class constructor

💡 Hint

Think about how the base part of the object must be ready before the derived part.

When creating a derived class object, the base class constructor runs first to initialize the base part, then the derived class constructor runs to initialize the derived part.

❓ Predict Output

advanced

Destructor call order in inheritance

What is the output of this program regarding destructor calls?

C++

#include <iostream>
class Base {
public:
    ~Base() { std::cout << "Base destructor\n"; }
};
class Derived : public Base {
public:
    ~Derived() { std::cout << "Derived destructor\n"; }
};

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

A

Only Base destructor

B

Base destructor
Derived destructor

C

Derived destructor
Base destructor

D No output

💡 Hint

Check if the base class destructor is virtual or not.

Because the base class destructor is not virtual, deleting a Derived object through a Base pointer calls only the Base destructor, causing a potential resource leak.

📝 Syntax

advanced

Identify the syntax error in constructor initialization

Which option contains the correct syntax for initializing member variables in a constructor initialization list?

C++

class Point {
    int x, y;
public:
    Point(int a, int b) : x(a), y(b) {}
};

A Point(int a, int b) { x = a; y = b; }

B Point(int a, int b) : x = a, y = b {}

C Point(int a, int b) : x(a), y(b) {}

D Point(int a, int b) : (x(a), y(b)) {}

💡 Hint

Look carefully at the colon and commas in the initialization list.

Option C correctly uses the constructor initialization list syntax with colon and commas. Option C uses assignment inside the constructor body, which is valid but not initialization list. Options C and D have syntax errors in the initialization list.

🚀 Application

expert

Predict object lifetime and output with dynamic allocation and scope

What is the output of this program considering object creation and destruction flow?

C++

#include <iostream>
class Demo {
public:
    Demo() { std::cout << "Created\n"; }
    ~Demo() { std::cout << "Destroyed\n"; }
};

int main() {
    Demo* d1 = new Demo();
    {
        Demo d2;
        Demo* d3 = new Demo();
        delete d3;
    }
    delete d1;
    return 0;
}

A

Created
Destroyed
Created
Destroyed
Destroyed

B

Created
Created
Destroyed
Destroyed
Destroyed

C

Created
Created
Destroyed
Destroyed

D

Created
Created
Destroyed
Created
Destroyed

💡 Hint

Remember when destructors are called for stack and heap objects.

d1 is created on heap (Created), then d2 on stack (Created), then d3 on heap (Created). d3 is deleted inside the block (Destroyed), then block ends and d2 is destroyed (Destroyed), finally d1 is deleted (Destroyed). Total 3 creations and 3 destructions in order.