Course contentsShow
← Computer Science
Lesson 2092 of 2,87247. Memory Management in LanguagesFree lesson

C++ RAII and Smart Pointers

Using Resource Acquisition Is Initialization and smart pointers (unique_ptr, shared_ptr) for safer manual management.

C++ RAII and Smart Pointers

You'll learn how C++ uses RAII and smart pointers to automate memory management and prevent common errors like leaks and dangling pointers.

The Core Idea

RAII (Resource Acquisition Is Initialization) is a C++ pattern where resource lifetime is tied to object lifetime. When an object is created, it acquires resources (like memory). When the object goes out of scope and is destroyed, its destructor automatically releases those resources. No manual cleanup needed!

Think of it like a hotel room key card: when you check in (object creation), you get the key (resource). When you check out (object destruction), the key automatically deactivates. You can't forget to return it — it happens automatically.

Smart Pointers

C++ provides smart pointers that implement RAII for dynamic memory:

unique_ptr

Represents exclusive ownership of a resource. Only one unique_ptr can own the memory at any time. When it goes out of scope, the memory is automatically freed.

{
    std::unique_ptr<int> ptr(new int(42));
    // Use ptr...
} // Memory automatically freed here

shared_ptr

Allows shared ownership through reference counting. Multiple shared_ptr objects can point to the same memory. The memory is freed only when the last shared_ptr is destroyed.

std::shared_ptr<int> ptr1(new int(100));
std::shared_ptr<int> ptr2 = ptr1; // Both own the resource
// Memory freed when both ptr1 and ptr2 are destroyed

Why This Matters

Smart pointers eliminate manual free() calls, preventing memory leaks and use-after-free bugs. They make ownership explicit and automatic.

Key Takeaway: RAII ties resource lifetime to object scope, and smart pointers (unique_ptr, shared_ptr) apply this principle to heap memory, providing safer automatic cleanup than manual memory management.