Smart Pointers

// Raw pointer issues:
// 1. Ownership unclear
// 2. Manual delete required
// 3. Exception safety problems
// 4. Easy to leak or double-free

void process() {
    Resource* r = new Resource();
    
    if (some_condition()) {
        return;  // Leak! delete never called
    }
    
    if (other_condition()) {
        throw std::runtime_error("error");  // Leak!
    }
    
    delete r;  // Easy to forget
}

#include <memory>

// Creating unique_ptr
auto ptr = std::make_unique<Resource>();  // Preferred
std::unique_ptr<Resource> ptr2(new Resource());  // Avoid direct new

// Automatic cleanup
void process() {
    auto r = std::make_unique<Resource>();
    
    if (some_condition()) {
        return;  // Resource freed automatically
    }
    
    throw std::runtime_error("error");  // Resource freed automatically
}  // Resource freed when ptr goes out of scope

// Transfer ownership
auto ptr2 = std::move(ptr);  // ptr is now empty
// ptr->doSomething();  // ERROR: nullptr dereference

// Pass to functions
void use_resource(const Resource* r);     // Borrow
void take_resource(std::unique_ptr<Resource> r);  // Take ownership
void maybe_modify(std::unique_ptr<Resource>& r);  // Might modify

// Creating shared_ptr
auto ptr = std::make_shared<Resource>();  // Preferred (single allocation)
std::shared_ptr<Resource> ptr2(new Resource());  // Two allocations

// Shared ownership
{
    auto ptr1 = std::make_shared<Resource>();
    {
        auto ptr2 = ptr1;  // Reference count = 2
        {
            auto ptr3 = ptr1;  // Reference count = 3
        }  // Reference count = 2
    }  // Reference count = 1
}  // Reference count = 0, Resource destroyed

// Custom deleter
auto file = std::shared_ptr<FILE>(
    fopen("data.txt", "r"),
    [](FILE* f) { if (f) fclose(f); }
);

// Problem: Circular reference causes leak
struct Node {
    std::shared_ptr<Node> next;
};

auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a;  // Memory leak! Neither will be destroyed

// Solution: weak_ptr
struct Node {
    std::weak_ptr<Node> next;  // Doesn't keep next alive
    
    void process() {
        if (auto shared = next.lock()) {  // Convert to shared_ptr
            // shared is valid, use it
        } else {
            // Node was destroyed
        }
    }
};

// std::make_unique (C++14)
auto ptr = std::make_unique<MyClass>(arg1, arg2);
// Benefits:
// - Exception safe
// - Single allocation
// - Cleaner syntax

// std::make_shared (C++11)
auto ptr = std::make_shared<MyClass>(arg1, arg2);
// Benefits:
// - Single allocation (object + control block together)
// - Better cache locality
// - Exception safe

// Avoid direct new:
std::unique_ptr<MyClass> bad(new MyClass());  // Exception unsafe
std::shared_ptr<MyClass> bad2(new MyClass());  // Two allocations