Chapter 19: Smart Pointers—Automatic Memory Management

The concepts of Encapsulation (Chapter 13) and RAII (Chapter 14 and 18) are foundational to safe C++ programming. We established that whenever you acquire a resource (like dynamic memory using new), you should immediately wrap it in an object whose destructor handles the cleanup (delete).

While RAII can be implemented for any resource, the most common resource is dynamic memory. Manually tracking ownership and calling delete is error-prone and leads to two major issues: **memory leaks** (forgetting to call delete) and **double deletion** (calling delete twice).

**Smart Pointers** are C++'s answer to this problem. They are wrappers around raw pointers that use the RAII principle to automatically manage the memory they point to. When the smart pointer object goes out of scope, its destructor is called, and the destructor calls delete on the wrapped raw pointer.

This chapter focuses on the three primary smart pointer types provided by the <memory> header: std::unique_ptr, std::shared_ptr, and std::weak_ptr.

Section 1: Unique Ownership (std::unique_ptr)

The std::unique_ptr is the simplest and most commonly used smart pointer. It enforces **exclusive ownership**: only one unique_ptr can point to a specific object at any given time.

Key Characteristics

• Ownership: Exclusive. When the unique_ptr is destroyed, the object it manages is automatically deleted.
• Copying: Cannot be copied (disallows unique_ptr<T> p2 = p1;).
• Moving: Can be transferred using move semantics (allows unique_ptr<T> p2 = std::move(p1);).

Example Usage (Creation and Destruction)

#include <iostream>
#include <memory>

class Resource {
public:
    Resource() { std::cout << "Resource Acquired" << std::endl; }
    ~Resource() { std::cout << "Resource Released" << std::endl; }
    void operation() { std::cout << "Resource operating." << std::endl; }
};

void demonstrate_unique_ptr() {
    std::cout << "--- Scope Start ---" << std::endl;
    {
        // Preferred way to create: using std::make_unique (C++14+)
        std::unique_ptr<Resource> p1 = std::make_unique<Resource>();
        p1->operation();

        // Transfer ownership to p2. p1 is now null.
        std::unique_ptr<Resource> p2 = std::move(p1); 
        
        if (p1 == nullptr) {
            std::cout << "p1 is now null." << std::endl;
        }

    } // <-- When p2 goes out of scope here, its destructor calls delete.
    std::cout << "--- Scope End (Resource is already deleted) ---" << std::endl;
}

Best Practice: Use std::make_unique
Always use std::make_unique<T>() instead of new T() when creating a unique_ptr. It is safer (exception-safe) and often more efficient.

Section 2: Shared Ownership (std::shared_ptr)

The std::shared_ptr allows **multiple pointers** to manage the same resource. It implements a **reference count** to track how many pointers currently own the resource.

Key Characteristics

• Ownership: Shared. The resource is deleted only when the last shared_ptr pointing to it is destroyed or reset.
• Copying: Can be copied. Copying increases the reference count.
• Reference Count: Stored externally in a "control block."

Example Usage (Shared Ownership)

void demonstrate_shared_ptr() {
    // 1. Create a shared pointer
    std::shared_ptr<Resource> p1 = std::make_shared<Resource>(); 
    std::cout << "Count (p1 only): " << p1.use_count() << std::endl; // Output: 1

    {
        // 2. Create a copy (shared ownership)
        std::shared_ptr<Resource> p2 = p1; 
        std::cout << "Count (p1 and p2): " << p1.use_count() << std::endl; // Output: 2

    } // <-- p2 goes out of scope. Count drops to 1. Resource is NOT deleted.
    
    std::cout << "Count (p1 only): " << p1.use_count() << std::endl; // Output: 1

} // <-- p1 goes out of scope. Count drops to 0. Resource is deleted.

Best Practice: Use std::make_shared
Always use std::make_shared<T>() instead of new T() for shared_ptr. It performs a single memory allocation for both the object (T) and the control block (reference count), which is significantly more efficient.

Section 3: Non-Owning Reference (std::weak_ptr)

The std::weak_ptr is used alongside std::shared_ptr. It holds a non-owning reference to an object managed by a shared_ptr. It does **not** increment the reference count.

Purpose: Breaking Circular Dependencies

If two objects hold shared_ptrs to each other (a circular dependency), the reference count of both objects will never reach zero, causing a permanent memory leak. A weak_ptr breaks this cycle by allowing one object to refer to the other without claiming ownership.

Key Characteristics

• Ownership: None. Does not affect the reference count.
• Access: Cannot directly access the object. You must convert it to a shared_ptr using the .lock() method before use.

void demonstrate_weak_ptr() {
    std::shared_ptr<int> shared_data = std::make_shared<int>(42);

    // Create a weak pointer from the shared pointer
    std::weak_ptr<int> weak_ref = shared_data;

    if (auto locked_ptr = weak_ref.lock()) {
        // We successfully "locked" the weak_ptr into a temporary shared_ptr
        std::cout << "Data is still alive: " << *locked_ptr << std::endl;
    } else {
        std::cout << "Data has been deleted." << std::endl;
    }
    
} // shared_data is destroyed here

Chapter 19 Conclusion and Next Steps

Smart Pointers are one of the most transformative features of modern C++. By delegating memory management to the standard library via the RAII principle, they virtually eliminate memory leaks and double-deletion errors, allowing you to focus on application logic. Rule of thumb: **Never use raw pointers for dynamic memory unless absolutely necessary; always prefer smart pointers.**

You have now mastered the core language features, OOP, and resource management. The final major frontier of modern C++ is the **Standard Template Library (STL)**, which provides highly optimized, ready-to-use data structures and algorithms.

In **Chapter 20**, we will begin our study of the STL by focusing on **Containers**, such as std::vector, std::list, and std::map.