Object lifecycle in C++ - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a constructor for the class.

C++

class MyClass {
public:
    [1]() {
        // Constructor body
    }
};

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

AMyClass

BMyClass()

Cvoid MyClass

D~MyClass

Attempts:

3 left

💡 Hint

Common Mistakes

Adding a return type like void to the constructor.

Using the destructor name (~MyClass) instead of the constructor.

The constructor has the same name as the class. Here, MyClass is the correct constructor name.

2fill in blank

medium

Complete the code to declare a destructor for the class.

C++

class MyClass {
public:
    [1]() {
        // Destructor body
    }
};

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

AMyClass

B~MyClass

Cvoid ~MyClass

DDestructor

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the tilde (~) before the class name.

Adding a return type like void to the destructor.

The destructor has the class name preceded by a tilde (~). Here, ~MyClass is the correct destructor name.

3fill in blank

hard

Fix the error in the constructor definition to properly initialize the member variable.

C++

class MyClass {
    int value;
public:
    MyClass(int v) {
        value [1] v;
    }
};

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

A:

B==

C=

D->

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' which is a comparison operator, not assignment.

Using ':' inside the constructor body instead of an initializer list.

To assign the parameter v to the member variable value, use the assignment operator =.

4fill in blank

hard

Fill both blanks to use an initializer list to initialize the member variable.

C++

class MyClass {
    int value;
public:
    MyClass(int v) [1] value[2] v) {}
};

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

A:

B=

C(

D{

Attempts:

3 left

💡 Hint

Common Mistakes

Using '=' instead of ':' to start the initializer list.

Using braces '{}' instead of parentheses '()' for initialization.

The initializer list starts with a colon (:), and member variables are initialized with parentheses ().

5fill in blank

hard

Complete the code to define a copy constructor that copies the member variable.

C++

class MyClass {
    int value;
public:
    MyClass(const MyClass& other) : value( [1] ) {}
};

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

A:

Bother.value

C(

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the colon to start the initializer list.

Using the wrong variable name or missing parentheses.

The copy constructor uses an initializer list starting with a colon (:), initializes value with parentheses, and copies from other.value.

Practice

1. Which of the following best describes when a destructor is called for an automatic (local) object in C++?

easy

A. When the object is created

B. When the object goes out of scope

C. When the program starts

D. Only when the object is deleted manually

Solution

1. Step 1: Understand automatic object lifecycle

   Automatic objects are created when their scope starts and destroyed when their scope ends.

2. Step 2: Identify destructor call timing

   The destructor is called automatically when the object goes out of scope to clean up resources.

3. Final Answer:

   When the object goes out of scope -> Option B

4. Quick Check:

   Destructor called at scope end = When object goes out of scope [OK]

Hint: Destructor runs automatically at scope end for local objects [OK]

Common Mistakes:

• Thinking destructor runs at object creation
• Believing manual deletion is needed for local objects
• Confusing program start with object destruction

2. Which of the following is the correct syntax to declare a destructor for a class named Car in C++?

easy

A. void Car();

B. destructor Car();

C. Car::~Car();

D. ~Car();

Solution

1. Step 1: Recall destructor syntax

   Destructor syntax uses a tilde (~) followed by the class name and parentheses.

2. Step 2: Match correct option

   ~Car(); matches the correct syntax: ~Car();

3. Final Answer:

   ~Car(); -> Option D

4. Quick Check:

   Destructor syntax = ~ClassName() [OK]

Hint: Destructor always starts with ~ followed by class name [OK]

Common Mistakes:

• Using void return type for destructor
• Writing destructor with class scope resolution in declaration
• Using keyword 'destructor' which doesn't exist

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

class Test {
public:
  Test() { std::cout << "Created "; }
  ~Test() { std::cout << "Destroyed "; }
};

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

medium

A. Created Created Destroyed Destroyed

B. Created Destroyed Created Destroyed

C. Created Created Destroyed

D. Destroyed Created Created Destroyed

Solution

1. Step 1: Trace object creation

   First, t1 is created: prints "Created ". Then inside inner scope, t2 is created: prints another "Created ".

2. Step 2: Trace object destruction

   When inner scope ends, t2 is destroyed: prints "Destroyed ". Then at program end, t1 is destroyed: prints "Destroyed ".

3. Final Answer:

   Created Created Destroyed Destroyed -> Option A

4. Quick Check:

   Constructor and destructor calls match output [OK]

Hint: Objects destroyed in reverse order of creation at scope end [OK]

Common Mistakes:

• Assuming destruction happens immediately after creation
• Forgetting inner scope destruction before outer
• Mixing order of constructor and destructor prints

4. Consider the following code snippet:

class Sample {
public:
  Sample() { std::cout << "Start "; }
  ~Sample() { std::cout << "End "; }
};

int main() {
  Sample* p = new Sample();
  // Missing delete p;
  return 0;
}

What is the problem with this code?

medium

A. Syntax error due to missing delete

B. Destructor is called twice causing error

C. Memory leak because destructor is not called

D. No problem, code runs fine

Solution

1. Step 1: Identify dynamic object creation

   The object is created with new, so it lives on the heap and needs manual deletion.

2. Step 2: Check for destructor call

   Since delete p; is missing, destructor is never called, causing a memory leak.

3. Final Answer:

   Memory leak because destructor is not called -> Option C

4. Quick Check:

   Missing delete on new object = memory leak [OK]

Hint: Always delete dynamically allocated objects to call destructor [OK]

Common Mistakes:

• Assuming destructor runs automatically for new objects
• Thinking missing delete causes syntax error
• Believing destructor is called twice

5. You want to track how many objects of class Box currently exist during program execution. Which approach correctly uses constructors and destructors to maintain this count?

hard

A. Increment a static counter in constructor and decrement it in destructor

B. Increment a global variable in constructor only

C. Decrement a static counter in constructor and increment in destructor

D. Use constructor to print count and destructor to reset count

Solution

1. Step 1: Understand object counting logic

   To track live objects, increase count when object is created and decrease when destroyed.

2. Step 2: Use static counter in class

   A static variable shared by all objects can hold the count, incremented in constructor and decremented in destructor.

3. Final Answer:

   Increment a static counter in constructor and decrement it in destructor -> Option A

4. Quick Check:

   Static counter + constructor increment + destructor decrement = correct count [OK]

Hint: Use static variable incremented in constructor, decremented in destructor [OK]

Common Mistakes:

• Changing count only in constructor or destructor, not both
• Using global variable instead of static class member
• Reversing increment and decrement roles