Beyond Manual Memory

The core idea is simple: use objects to manage resources. When the object is created, it acquires the resource. When the object is destroyed, it releases the resource. This principle is called Resource Acquisition Is Initialization (RAII).

std::unique_ptr for Exclusive Ownership A unique_ptr exclusively owns the object it points to. Think of it as a key to a house. Only one person has the key at a time. You can't copy a unique_ptr, because that would mean two pointers think they have exclusive ownership of the same memory. You can, however, move ownership from one unique_ptr to another, like handing the key to someone else.

#include <memory>
#include <iostream>

class MyObject {
public:
    MyObject() { std::cout << "MyObject created\n"; }
    ~MyObject() { std::cout << "MyObject destroyed\n"; }
    void doSomething() { std::cout << "Doing something!\n"; }
};

int main() {
    // Create a unique_ptr. Memory is allocated here.
    auto ptr1 = std::make_unique<MyObject>();
    ptr1->doSomething();

    // auto ptr2 = ptr1; // This line won't compile! Cannot copy.

    // Move ownership from ptr1 to ptr2
    std::unique_ptr<MyObject> ptr2 = std::move(ptr1);
    
    // Now ptr1 is null, and ptr2 owns the object.
    if (!ptr1) {
        std::cout << "ptr1 is now null.\n";
    }
    ptr2->doSomething();

    // ptr2 goes out of scope, MyObject is automatically destroyed.
    return 0;
}

std::shared_ptr for Shared Ownership Sometimes, multiple parts of a program need to share access to the same object, and any of them could be the last one to finish using it. A shared_ptr handles this scenario. It keeps an internal counter of how many shared_ptrs are pointing to the object. Each time a new shared_ptr is copied, the count goes up. When a shared_ptr is destroyed, the count goes down. The memory is only deallocated when the count reaches zero.

#include <memory>
#include <iostream>

class SharedResource {
public:
    SharedResource() { std::cout << "Resource created\n"; }
    ~SharedResource() { std::cout << "Resource destroyed\n"; }
};

void use_resource(std::shared_ptr<SharedResource> ptr) {
    std::cout << "Using resource. Count is: " << ptr.use_count() << std::endl;
} // ptr goes out of scope, count decreases

int main() {
    std::shared_ptr<SharedResource> p1;
    {
        auto p2 = std::make_shared<SharedResource>();
        std::cout << "Initial count: " << p2.use_count() << std::endl;

        p1 = p2; // Copy p2. Count increases.
        std::cout << "After copy: " << p1.use_count() << std::endl;

        use_resource(p1); // Pass by value, count increases temporarily.

        std::cout << "p2 is about to go out of scope.\n";
    } // p2 is destroyed, count decreases.

    std::cout << "Final count before main ends: " << p1.use_count() << std::endl;

    return 0; // p1 is destroyed, count becomes 0, Resource is destroyed.
}

In multithreaded applications, memory pools offer another advantage. A global heap requires synchronization (like mutexes) to prevent race conditions when multiple threads try to allocate memory at once. This synchronization adds overhead. By giving each thread its own private memory pool, you can avoid this contention entirely, allowing threads to allocate memory without blocking each other.