ProgramGuru

Tie Cleanup to Lifetime

Tie Cleanup to Lifetime

Resource acquisition is initialization, or RAII, ties resource cleanup to an object’s destructor.

Leaving a scope destroys its local owners, so normal and exception paths need less manual cleanup code.

Before this lesson, review Understand Manual Allocation when needed.

What you’ll learn

  • Use raii and destructors to tie Cleanup to Lifetime.
  • Explain how the complete example produces Opened → Working → Closed → After scope.
  • Make the practice change and explain why the result changes or stays the same.

Follow a complete C++ example

Leaving a scope destroys its local owners, so normal and exception paths need less manual cleanup code.

Read the declarations above main before tracing its statements. Each declared name supplies the value, type or operation used later. The std:: prefix selects a name from the standard library, and cout << sends a value to the output stream.

C++17 · main.cpp · complete program

#include <iostream>

struct Report  {
  Report()  {
    std::cout << "Opened\n";
  }
  ~Report()  {
    std::cout << "Closed\n";
  }
}
;
int main()  {
  {
    Report report;
    std::cout << "Working" << '\n';
  }
  std::cout << "After scope" << '\n';
  return 0;
}

Expected output

Opened
Working
Closed
After scope
Run in C++ compiler →

Connect the code to its result

C++17 · source used in this explanation

#include <iostream>

struct Report  {
  Report()  {
    std::cout << "Opened\n";
  }
  ~Report()  {
    std::cout << "Closed\n";
  }
}
;
int main()  {
  {
    Report report;
    std::cout << "Working" << '\n';
  }
  std::cout << "After scope" << '\n';
  return 0;
}

Expected output

Opened
Working
Closed
After scope

Resource acquisition is initialization, or RAII, ties resource cleanup to an object’s destructor. Leaving a scope destroys its local owners, so normal and exception paths need less manual cleanup code.

Trace the result: Read the complete program below from its starting values to the output operations. Each std::cout statement displays the value supplied at that point; \n begins the next line. The resulting lines, in order, are Opened → Working → Closed → After scope. In this example, distinguish what the program calculates or changes from what it actually displays.

Tie Cleanup to Lifetime: cause and effect

  1. Operation

    Resource acquisition is initialization, or RAII, ties resource cleanup to an object’s destructor.

  2. Effect on school data

    Leaving a scope destroys its local owners, so normal and exception paths need less manual cleanup code.

  3. Observed result

    The program displays these lines after the shown operations.

    Opened
Working
Closed
After scope
Conceptual relationship for the actual program above; this visual does not execute C++.

Important mistakes and boundaries

A destructor should not throw during stack unwinding. RAII only helps when the resource is actually held by a correctly designed owner.

Change the school example

C++17 · edit this complete example

#include <iostream>

struct Report  {
  Report()  {
    std::cout << "Opened\n";
  }
  ~Report()  {
    std::cout << "Closed\n";
  }
}
;
int main()  {
  {
    Report report;
    std::cout << "Working" << '\n';
  }
  std::cout << "After scope" << '\n';
  return 0;
}

Your task: Remove Working. Before running your edited program, predict the new output and explain which stored value, condition or object changes. Keep the rest of the example intact.

Use the complete source repeated here; this task does not depend on remembering code from another section.

Worked answer and reasoning

Worked variation: Remove Working. Opened and Closed still surround the scope, followed by After scope.

Resource acquisition is initialization, or RAII, ties resource cleanup to an object’s destructor. Leaving a scope destroys its local owners, so normal and exception paths need less manual cleanup code.

A destructor should not throw during stack unwinding. RAII only helps when the resource is actually held by a correctly designed owner.

For a baseline run, save this source as main.cpp and use clang++ -std=c++17 -Wall -Wextra -pedantic main.cpp -o school, or equivalent g++ flags. Recompile after editing so that you run the updated executable.

The source and output below belong to the edited program. Compare them with the original example to see the consequence of this single change.

C++17 · worked variation · complete program

#include <iostream>

struct Report  {
  Report()  {
    std::cout << "Opened\n";
  }
  ~Report()  {
    std::cout << "Closed\n";
  }
}
;
int main()  {
  {
    Report report;
    
  }
  std::cout << "After scope" << '\n';
  return 0;
}

Expected output

Opened
Closed
After scope
Run in C++ compiler →

Check your understanding

C++17 · original program for this question

#include <iostream>

struct Report  {
  Report()  {
    std::cout << "Opened\n";
  }
  ~Report()  {
    std::cout << "Closed\n";
  }
}
;
int main()  {
  {
    Report report;
    std::cout << "Working" << '\n';
  }
  std::cout << "After scope" << '\n';
  return 0;
}
Before making the practice edit, what does the original C++17 program print?
Choose one answer. You can try again.

Answer and explanation

Opened Working Closed After scope

Resource acquisition is initialization, or RAII, ties resource cleanup to an object’s destructor. Leaving a scope destroys its local owners, so normal and exception paths need less manual cleanup code. A destructor should not throw during stack unwinding. RAII only helps when the resource is actually held by a correctly designed owner.

Check a common mistake

What makes RAII useful when a function exits early?
Choose one answer. You can try again.

Answer and explanation

Local resource owners clean up through their destructors.

RAII manages lifetime-bound cleanup; it does not turn failures into success or suppress exceptions.

What to remember

Resource acquisition is initialization, or RAII, ties resource cleanup to an object’s destructor. A destructor should not throw during stack unwinding. RAII only helps when the resource is actually held by a correctly designed owner.

Useful connections: Understand Manual Allocation, Give a Task a Name.

Language and design guidance: C++ Core Guidelines and C++ working draft. The draft describes an evolving language; these examples deliberately target C++17.

Reaching the recap and completing the quizzes are separate milestones.

    Next lesson: Give One Owner Responsibility →