int x = 42;
int* ptr = &x;       // ptr holds the address of x

std::cout << ptr;     // prints address, e.g. 0x7ffd5e8c
std::cout << *ptr;    // 42 — dereference: access the value at that address

*ptr = 100;           // modifies x through the pointer
std::cout << x;       // 100

void leak() {
    int* p = new int(42);
    return;  // p's memory is NEVER freed — leaked!
}

int* p = new int(42);
delete p;
delete p;  // UNDEFINED BEHAVIOR — corrupts the heap allocator

int* p = new int(42);
delete p;
*p = 10;   // UNDEFINED BEHAVIOR — p points to freed memory

int* getVal() {
    int local = 42;
    return &local;  // BAD: local is destroyed when function returns
}
// Caller gets a dangling pointer!

class FileHandle {
    FILE* file;
public:
    FileHandle(const char* path) : file(fopen(path, "r")) {
        if (!file) throw std::runtime_error("Cannot open file");
    }
    ~FileHandle() {
        if (file) fclose(file);  // guaranteed cleanup
    }
    
    // Delete copy (file handles shouldn't be duplicated)
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
    
    // Allow move (transfer ownership)
    FileHandle(FileHandle&& other) noexcept : file(other.file) {
        other.file = nullptr;
    }
    
    FILE* get() const { return file; }
};

void process() {
    FileHandle fh("data.txt");    // resource acquired in constructor
    // ... use fh.get() ...
}   // fh destroyed here → file automatically closed
    // Even if an exception is thrown between construction and here!

#include <memory>

// Creating (prefer make_unique)
auto p = std::make_unique<int>(42);       // PREFERRED ✓
std::unique_ptr<int> p2(new int(42));     // also works

// Usage — same as a raw pointer
std::cout << *p;     // 42
*p = 100;

// Array version
auto arr = std::make_unique<int[]>(100);
arr[0] = 42;

// Cannot copy — ownership is EXCLUSIVE
// auto p3 = p;  // ERROR: deleted copy constructor

// Can move — TRANSFER ownership
auto p3 = std::move(p);  // p is now nullptr, p3 owns the memory

// Custom deleter (e.g., for C APIs)
auto file_ptr = std::unique_ptr<FILE, decltype(&fclose)>(
    fopen("data.txt", "r"), &fclose);

auto sp1 = std::make_shared<int>(42);  // reference count = 1
auto sp2 = sp1;                         // reference count = 2
auto sp3 = sp1;                         // reference count = 3

sp2.reset();                            // reference count = 2
sp3 = nullptr;                          // reference count = 1
// when sp1 goes out of scope → count = 0 → memory freed automatically

std::shared_ptr<int> sp = std::make_shared<int>(42);
std::weak_ptr<int> wp = sp;  // does NOT increase ref count

// Must lock() before using — converts to shared_ptr if still alive
if (auto locked = wp.lock()) {
    std::cout << *locked;    // safe to use
} else {
    // the object has been destroyed
}

wp.expired();  // true if the managed object is gone

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;  // weak breaks the cycle!
};
// Without weak_ptr: A→B→A→B→... ref count never hits 0 → MEMORY LEAK

class PoolAllocator {
    char* pool;
    size_t offset;
    size_t capacity;
public:
    PoolAllocator(size_t size)
        : pool(new char[size]), offset(0), capacity(size) {}
    ~PoolAllocator() { delete[] pool; }
    
    void* allocate(size_t bytes) {
        if (offset + bytes > capacity) throw std::bad_alloc();
        void* ptr = pool + offset;
        offset += bytes;
        return ptr;
    }
    
    void reset() { offset = 0; }  // "free" everything at once — O(1)
};