Smart Pointers (unique_ptr, shared_ptr, weak_ptr)

#include <cstddef>
#include <iostream>
#include <string>
#include <utility>

template <typename T>
class SimpleUniquePtr {
    T* ptr_{nullptr};

public:
    // 1. Constructors & Destructor
    explicit SimpleUniquePtr(T* p = nullptr) noexcept : ptr_(p) {}
    ~SimpleUniquePtr() noexcept { delete ptr_; }

    // 2. Deleted Copy Operations (Exclusive Ownership Invariant)
    SimpleUniquePtr(const SimpleUniquePtr&) = delete;
    SimpleUniquePtr& operator=(const SimpleUniquePtr&) = delete;

    // 3. Move Semantics: Transfer ownership and nullify source
    SimpleUniquePtr(SimpleUniquePtr&& other) noexcept
        : ptr_(std::exchange(other.ptr_, nullptr)) {}

    SimpleUniquePtr& operator=(SimpleUniquePtr&& other) noexcept {
        if (this != &other) {
            delete ptr_; // Free currently owned resource
            ptr_ = std::exchange(other.ptr_, nullptr);
        }
        return *this;
    }

    // 4. Observers & Modifiers
    T& operator*() const noexcept { return *ptr_; }
    T* operator->() const noexcept { return ptr_; }
    T* get() const noexcept { return ptr_; }
    explicit operator bool() const noexcept { return ptr_ != nullptr; }

    T* release() noexcept { return std::exchange(ptr_, nullptr); }
    void reset(T* p = nullptr) noexcept {
        if (ptr_ != p) {
            delete ptr_;
            ptr_ = p;
        }
    }
};

int main() {
    std::cout << "--- SimpleUniquePtr Construction & Dereference ---\n";
    SimpleUniquePtr<std::string> p1(new std::string("C++23 UniquePtr"));
    std::cout << "p1 value: " << *p1 << ", length: " << p1->length() << '\n';
    std::cout << "p1 holds resource: " << std::boolalpha << static_cast<bool>(p1) << '\n';

    std::cout << "\n--- Move Construction ---\n";
    SimpleUniquePtr<std::string> p2(std::move(p1));
    std::cout << "p1 is now: " << (p1 ? *p1 : "null") << '\n';
    std::cout << "p2 holds:  " << *p2 << '\n';

    std::cout << "\n--- Move Assignment ---\n";
    SimpleUniquePtr<std::string> p3;
    p3 = std::move(p2);
    std::cout << "p2 is now: " << (p2 ? *p2 : "null") << '\n';
    std::cout << "p3 holds:  " << *p3 << '\n';

    std::cout << "\n--- Reset & Release ---\n";
    p3.reset(new std::string("Replaced string"));
    std::cout << "p3 after reset: " << *p3 << '\n';

    std::string* raw = p3.release();
    std::cout << "p3 after release: " << (p3 ? *p3 : "null") << '\n';
    std::cout << "Released raw pointer: " << *raw << '\n';
    delete raw; // Manual deletion of released resource

    return 0;
}

#include <cstddef>
#include <memory>
#include <print>
#include <string>

// ============================================================================
// 1. UNIQUE_PTR & EXCLUSIVE RAII OWNERSHIP
// - sizeof(std::unique_ptr<T>) == 8 bytes (identical to raw pointer).
// - Zero memory overhead, zero runtime CPU cost compared to manual delete.
// - Stateless deleter: empty base class optimization (EBO) keeps size at 8 bytes.
// ============================================================================

// Custom resource simulating an OS socket descriptor
struct SocketHandle {
    int fd;
    explicit SocketHandle(int descriptor) : fd(descriptor) {
        std::println("  [SocketHandle] Opened fd={}", fd);
    }
    ~SocketHandle() {
        std::println("  [SocketHandle] Closed fd={}", fd);
    }
};

// Stateless custom deleter for unique_ptr (zero space overhead!)
struct SocketDeleter {
    void operator()(SocketHandle* sock) const noexcept {
        std::println("  [CustomDeleter] Executing custom socket cleanup for fd={}", sock ? sock->fd : -1);
        delete sock;
    }
};

int main() {
    std::println("--- 1. std::unique_ptr & Ownership Transfer ---");
    std::println("sizeof(unique_ptr<int>): {} bytes (raw pointer size)", sizeof(std::unique_ptr<int>));
    std::println("sizeof(unique_ptr with stateless deleter): {} bytes",
                 sizeof(std::unique_ptr<SocketHandle, SocketDeleter>));

    {
        // Step 1: std::make_unique allocates both object and pointer in single statement
        auto u1 = std::make_unique<std::string>("Exclusive Resource");
        std::println("u1 owns: \"{}\", valid = {}", *u1, u1 != nullptr);

        // Step 2: Ownership transfer via std::move
        std::unique_ptr<std::string> u2 = std::move(u1);
        std::println("After std::move: u1 is {}, u2 owns \"{}\"",
                     u1 ? "non-null" : "nullptr", *u2);

        // Step 3: Reset releases old object and takes ownership of new
        u2.reset(new std::string("Replaced Resource"));
        std::println("After reset: u2 owns \"{}\"", *u2);
    }

    std::println("\n--- Custom Deleter with unique_ptr ---");
    {
        std::unique_ptr<SocketHandle, SocketDeleter> sockPtr(new SocketHandle(42));
    } // SocketDeleter called automatically on scope exit

    // ========================================================================
    // 2. SHARED_PTR & CONTROL BLOCK TRACKING
    // - sizeof(std::shared_ptr<T>) == 16 bytes (pointer to object + pointer to control block).
    // - Atomic strong ref counting across nested scopes.
    // ========================================================================
    std::println("\n--- 2. std::shared_ptr & Control Block Tracking ---");
    std::println("sizeof(shared_ptr<int>): {} bytes (object ptr + control block ptr)",
                 sizeof(std::shared_ptr<int>));

    std::shared_ptr<int> sp1 = std::make_shared<int>(100);
    std::println("sp1 created: value = {}, use_count = {}", *sp1, sp1.use_count());
    {
        std::shared_ptr<int> sp2 = sp1;
        std::println("sp2 created (copy of sp1): sp1.use_count = {}, sp2.use_count = {}",
                     sp1.use_count(), sp2.use_count());
        {
            std::shared_ptr<int> sp3 = sp2;
            std::println("sp3 created (copy of sp2): use_count = {}", sp1.use_count());
        }
        std::println("sp3 destroyed: use_count = {}", sp1.use_count());
    }
    std::println("sp2 destroyed: use_count = {}", sp1.use_count());

    // ========================================================================
    // 3. WEAK_PTR: SAFE OBSERVER & UPGRADING
    // - sizeof(std::weak_ptr<T>) == 16 bytes.
    // - Observes object without incrementing use_count; upgraded via lock().
    // ========================================================================
    std::println("\n--- 3. std::weak_ptr Safe Observer & Upgrading ---");
    std::println("sizeof(weak_ptr<int>): {} bytes (object ptr + control block ptr)",
                 sizeof(std::weak_ptr<int>));

    std::weak_ptr<int> wp = sp1;
    std::println("weak_ptr bound to sp1: sp1.use_count = {}, wp.expired() = {}",
                 sp1.use_count(), wp.expired());

    if (auto locked = wp.lock()) {
        std::println("wp.lock() succeeded: value = {}, temp use_count = {}",
                     *locked, locked.use_count());
    }

    sp1.reset();
    std::println("sp1.reset() called: wp.expired() = {}", wp.expired());

    if (auto locked = wp.lock()) {
        std::println("wp.lock() succeeded unexpectedly");
    } else {
        std::println("wp.lock() returned nullptr because managed object is dead");
    }

    return 0;
}