Stack vs Heap, Placement new & Memory Layout

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

template <typename T>
class FixedSlot {
    // 1. Raw byte storage strictly aligned to T's natural requirement
    alignas(T) unsigned char storage_[sizeof(T)];
    bool occupied_{false};

public:
    FixedSlot() noexcept = default;

    ~FixedSlot() {
        reset();
    }

    // In-place construction using placement new
    template <typename... Args>
    T* emplace(Args&&... args) {
        reset(); // Destroy existing object before overwriting
        T* ptr = ::new (static_cast<void*>(storage_)) T(std::forward<Args>(args)...);
        occupied_ = true;
        return ptr;
    }

    // Explicit destructor call (NEVER delete!)
    void reset() noexcept {
        if (occupied_) {
            reinterpret_cast<T*>(storage_)->~T();
            occupied_ = false;
        }
    }

    T* get() noexcept {
        return occupied_ ? reinterpret_cast<T*>(storage_) : nullptr;
    }

    const T* get() const noexcept {
        return occupied_ ? reinterpret_cast<const T*>(storage_) : nullptr;
    }
};

int main() {
    std::cout << "--- FixedSlot<std::string> Stack Placement New ---\n";
    FixedSlot<std::string> slot;
    std::cout << "slot.get() initially: " << (slot.get() ? *slot.get() : "nullptr") << '\n';

    slot.emplace("Placement New String in Stack Buffer");
    std::cout << "After emplace: " << *slot.get() << '\n';

    // Emplace again to verify reset() called before new placement
    slot.emplace("Replaced In-Place Object");
    std::cout << "After second emplace: " << *slot.get() << '\n';

    // Const accessor test
    const auto& constSlot = slot;
    if (constSlot.get()) {
        std::cout << "Const access: " << *constSlot.get() << '\n';
    }

    // Reset clears occupancy and invokes destructor
    slot.reset();
    std::cout << "After reset, slot.get(): " << (slot.get() ? "active" : "nullptr") << '\n';

    return 0;
}

#include <cstddef>
#include <cstdint>
#include <new>
#include <print>
#include <string>
#include <utility>

// ============================================================================
// 1. LIFECYCLE INSTRUMENTATION
// Tracks exact constructor and destructor execution to prove when memory
// is allocated vs when C++ object lifetime actually begins and ends.
// ============================================================================

struct TrackedResource {
    inline static int defaultCtorCount = 0;
    inline static int paramCtorCount = 0;
    inline static int dtorCount = 0;

    int id{0};
    std::string tag{};

    // Default constructor
    TrackedResource() : id(0), tag("default") {
        ++defaultCtorCount;
        std::println("  [TrackedResource] Default Ctor id={}", id);
    }

    // Parameterized constructor
    TrackedResource(int idVal, std::string tagVal) : id(idVal), tag(std::move(tagVal)) {
        ++paramCtorCount;
        std::println("  [TrackedResource] Param Ctor id={} tag={}", id, tag);
    }

    // Destructor
    ~TrackedResource() {
        ++dtorCount;
        std::println("  [TrackedResource] Dtor id={} tag={}", id, tag);
    }
};

// ============================================================================
// 2. STACK-BACKED PLACEMENT NEW STORAGE
// Pre-allocates raw uninitialized bytes on the CPU STACK with zero heap overhead.
// Demonstrates how std::optional, std::variant, and high-frequency systems work.
// ============================================================================

template <typename T>
class StackObjectSlot {
    // alignas(T) guarantees correct memory boundary alignment (e.g. 8-byte aligned)
    // unsigned char storage_ reserves raw uninitialized bytes without constructing T
    alignas(T) unsigned char storage_[sizeof(T)];
    bool occupied_{false}; // Tracks whether a live C++ object currently inhabits the slot

public:
    StackObjectSlot() noexcept = default;

    // Destructor: If an object exists, we MUST manually call its destructor!
    ~StackObjectSlot() {
        reset();
    }

    // Disable copies to prevent double-destruction bugs
    StackObjectSlot(const StackObjectSlot&) = delete;
    StackObjectSlot& operator=(const StackObjectSlot&) = delete;

    // Step 1: Placement new construction
    // Forwarding parameters directly into T's constructor inside our stack buffer
    template <typename... Args>
    T* emplace(Args&&... args) {
        if (occupied_) {
            reset(); // Clean up existing object before overwriting memory
        }

        // Placement new syntax: new (address) Type(arguments)
        // Performs NO dynamic heap allocation (malloc/operator new).
        // Only executes the constructor directly at &storage_[0].
        T* ptr = ::new (static_cast<void*>(storage_)) T(std::forward<Args>(args)...);
        occupied_ = true;
        return ptr;
    }

    // Step 2: Accessing the live object
    [[nodiscard]] T* get() noexcept {
        return occupied_ ? reinterpret_cast<T*>(storage_) : nullptr;
    }

    [[nodiscard]] const T* get() const noexcept {
        return occupied_ ? reinterpret_cast<const T*>(storage_) : nullptr;
    }

    // Step 3: Manual destructor invocation
    // Required because placement new did not allocate via heap 'new', so 'delete' CANNOT be called!
    void reset() noexcept {
        if (occupied_) {
            get()->~T(); // Explicit destructor call resets object state
            occupied_ = false;
        }
    }

    [[nodiscard]] bool hasValue() const noexcept { return occupied_; }
};

int main() {
    std::println("--- Stack vs Heap Placement New Demonstration ---");
    StackObjectSlot<TrackedResource> slot;

    // Emplace Alpha
    TrackedResource* pAlpha = slot.emplace(101, "Alpha");
    bool aligned = (reinterpret_cast<std::uintptr_t>(pAlpha) % alignof(TrackedResource) == 0);
    std::println("Emplaced Alpha in stack slot: correctly aligned = {}", aligned);
    std::println("Slot content: id={}, tag={}", slot.get()->id, slot.get()->tag);

    // Emplace Beta (overwriting Alpha)
    std::println("Emplacing Beta (triggers in-place destruction of Alpha):");
    slot.emplace(202, "Beta");
    std::println("Slot content: id={}, tag={}", slot.get()->id, slot.get()->tag);

    // Explicit reset
    std::println("Explicit reset of stack slot:");
    slot.reset();
    std::println("Slot occupied after reset = {}", slot.hasValue());

    int active = (TrackedResource::paramCtorCount + TrackedResource::defaultCtorCount) - TrackedResource::dtorCount;
    std::println("Lifecycle counts: paramCtors={}, dtors={}, active={}",
                 TrackedResource::paramCtorCount, TrackedResource::dtorCount, active);
    std::println("StackObjectSlot size: {} bytes, zero heap allocations",
                 sizeof(StackObjectSlot<TrackedResource>));

    return 0;
}