#include <memory>

// In heap's expanse, where bytes and bits run free
// We allocate and clear, a dance of memory

class MemoryManager {
public:
    // With 'new' we claim a space for data's glee
    // And 'delete' we call, to set it free
    template <typename T>
    T* allocate() {
        return new T();
    }

    template <typename T>
    void deallocate(T* ptr) {
        delete ptr;
    }

    // A shared_ptr's reign, a team of ownership, three
    // When last ref falls, the object's soul is free
    template <typename T>
    std::shared_ptr<T> makeShared() {
        return std::make_shared<T>();
    }

    // The unique_ptr stands, alone in its debris
    // Moving on, it leaves old mem to fly free
    template <typename T>
    std::unique_ptr<T> makeUnique() {
        return std::make_unique<T>();
    }
};

// In cycles deep, where smart pointers agree
// To break the chains, and set each other free
MemoryManager manager;

Memory Management Ghazal

#include <memory>
#include <vector>
#include <optional>

// Love flows through cycles of attachment and release
template<typename Heart>
class shared_love {
private:
    std::shared_ptr<Heart> bond;          // Strong attachment
    std::weak_ptr<Heart> memories;        // What remains
    std::vector<std::weak_ptr<Heart>> past_loves;

    // Each heart carries its own sorrows
    struct wound {
        std::string pain;
        bool healed = false;
    };
    
    std::optional<wound> heartbreak;

public:
    shared_love() {
        // When love first awakens
        // Pure and unattached
        bond = std::make_shared<Heart>();
    }

    void connect(shared_love& other) {
        // Two hearts sharing one space
        // Reference count grows with love
        bond = other.bond;
    }

    void remember() {
        // Hold gently what once was strong
        memories = bond;
    }

    bool still_attached() const {
        // Do we hold too tightly?
        return bond.use_count() > 1;
    }

    bool still_remembers() const {
        // Some loves never fully fade
        return !memories.expired();
    }

    void let_go() {
        // Keep only a weak reference
        // To what once was everything
        remember();
        past_loves.push_back(memories);
        
        // Release the strong bond
        // Watch the reference count fall
        bond.reset();
        
        // Mark the moment of release
        heartbreak = wound{"Time heals"};
    }

    void heal() {
        // Scars remind us we survived
        if (heartbreak) {
            heartbreak->healed = true;
        }
    }

    ~shared_love() {
        // When the last reference falls
        // Love returns to the void
        // Yet memories remain
        // Until they too fade to null
    }
};

Love's Reference Count

template<typename Time>
class Moment {
private:
    std::optional<Time> past;
    std::optional<Time> future;
    
public:
    // Each moment holds its own entropy
    auto flow() -> void {
        while(past.has_value()) {
            future.reset();
            past = std::move(future);
        } // time flows one way
    }
};

C++

History

Paradigms