Move Semantics: Missing noexcept Killed Vector Performance

#include <iostream>
#include <string>

// Overload set that lets us observe which value category the compiler sees
void inspect(const std::string& text) {
    std::cout << "lvalue reference overload called: " << text << "\n";
}

void inspect(std::string&& text) {
    std::cout << "rvalue reference overload called: " << text << "\n";
}

std::string generateGreeting() {
    return "Hello from a temporary";  // Returns a temporary (rvalue)
}

int main() {
    std::string persistentName = "Alice";  // persistentName is an lvalue

    inspect(persistentName);          // Binds to const T& — lvalue overload
    inspect(generateGreeting());      // Binds to T&&    — rvalue overload (temporary)
    inspect("raw string literal");    // Also an rvalue — rvalue overload

    // KEY INSIGHT: an rvalue reference variable is itself an lvalue
    std::string&& capturedTemp = generateGreeting();
    inspect(capturedTemp);            // Calls LVALUE overload — because capturedTemp has a name!
    inspect(std::move(capturedTemp)); // std::move casts it back to rvalue — rvalue overload

    return 0;
}

#include <iostream>
#include <cstring>
#include <utility>
#include <stdexcept>

class ManagedBuffer {
public:
    // ── Construction ─────────────────────────────────────────────────────────
    explicit ManagedBuffer(std::size_t capacity)
        : data_(new double[capacity])   // Heap allocation — the expensive resource
        , capacity_(capacity)
        , size_(0)
    {
        std::cout << "[Construct] Allocated " << capacity << " doubles\n";
    }

    // ── Destructor ────────────────────────────────────────────────────────────
    ~ManagedBuffer() {
        delete[] data_;  // data_ may be nullptr after a move — delete[] nullptr is safe
        std::cout << "[Destruct]  Released buffer (capacity=" << capacity_ << ")\n";
    }

    // ── Copy constructor — deep copy, expensive ───────────────────────────────
    ManagedBuffer(const ManagedBuffer& other)
        : data_(new double[other.capacity_])
        , capacity_(other.capacity_)
        , size_(other.size_)
    {
        std::memcpy(data_, other.data_, size_ * sizeof(double));
        std::cout << "[Copy]      Copied " << size_ << " doubles (deep copy!)\n";
    }

    // ── Move constructor — pointer swap, O(1), noexcept IS REQUIRED ───────────
    ManagedBuffer(ManagedBuffer&& other) noexcept
        : data_(other.data_)            // Steal the heap pointer
        , capacity_(other.capacity_)    // Steal metadata
        , size_(other.size_)
    {
        other.data_     = nullptr;  // Leave source in valid-but-empty state
        other.capacity_ = 0;        // Source destructor will call delete[] nullptr — safe
        other.size_     = 0;
        std::cout << "[Move]      Moved buffer — no allocation, O(1)\n";
    }

    // ── Copy assignment — Rule of Five ────────────────────────────────────────
    ManagedBuffer& operator=(const ManagedBuffer& other) {
        if (this == &other) return *this;         // Self-assignment guard
        ManagedBuffer temp(other);                // Copy-and-swap idiom
        swap(temp);
        return *this;
    }

    // ── Move assignment — release ours, steal theirs ──────────────────────────
    ManagedBuffer& operator=(ManagedBuffer&& other) noexcept {
        if (this == &other) return *this;         // Self-move guard (rare but must handle)
        delete[] data_;           // Release OUR resource first
        data_     = other.data_;  // Steal source's pointer
        capacity_ = other.capacity_;
        size_     = other.size_;
        other.data_     = nullptr;  // Disarm the source
        other.capacity_ = 0;
        other.size_     = 0;
        std::cout << "[MoveAssign] Transferred ownership\n";
        return *this;
    }

    void push(double value) {
        if (size_ >= capacity_) throw std::runtime_error("Buffer full");
        data_[size_++] = value;
    }

    std::size_t size()     const { return size_; }
    std::size_t capacity() const { return capacity_; }

private:
    void swap(ManagedBuffer& other) noexcept {
        std::swap(data_,     other.data_);
        std::swap(capacity_, other.capacity_);
        std::swap(size_,     other.size_);
    }

    double*     data_;
    std::size_t capacity_;
    std::size_t size_;
};

// Factory function — caller gets ownership transferred via move, no copy
ManagedBuffer createSensorReadings(std::size_t count) {
    ManagedBuffer readings(count);
    for (std::size_t i = 0; i < count; ++i)
        readings.push(static_cast<double>(i) * 1.5);
    return readings;  // NRVO may elide this move entirely — but move is the fallback
}

int main() {
    std::cout << "=== Factory call (NRVO or move) ===\n";
    ManagedBuffer sensorData = createSensorReadings(4);
    std::cout << "sensorData has " << sensorData.size() << " readings\n\n";

    std::cout << "=== Explicit move into new owner ===\n";
    ManagedBuffer archiveBuffer(10);
    archiveBuffer = std::move(sensorData);  // Move assignment — sensorData is now empty
    std::cout << "archiveBuffer size: " << archiveBuffer.size()
              << "  sensorData size: "  << sensorData.size() << "\n\n";

    std::cout << "=== Destructors run as stack unwinds ===\n";
    return 0;
}

#include <iostream>
#include <string>
#include <memory>
#include <utility>
#include <vector>

struct NetworkPacket {
    std::string  payload;
    int          priority;

    // Observe which constructor fires
    NetworkPacket(std::string p, int prio)
        : payload(std::move(p)), priority(prio) {
        std::cout << "  [Construct] payload='" << payload << "' priority=" << priority << "\n";
    }

    NetworkPacket(const NetworkPacket& other)
        : payload(other.payload), priority(other.priority) {
        std::cout << "  [Copy]      payload='" << payload << "'\n";
    }

    NetworkPacket(NetworkPacket&& other) noexcept
        : payload(std::move(other.payload)), priority(other.priority) {
        std::cout << "  [Move]      payload='" << payload << "'\n";
    }
};

// ── Perfect forwarding factory — preserves value category of every argument ──
template <typename T, typename... Args>
std::unique_ptr<T> makeUnique(Args&&... args) {
    // std::forward preserves: lvalue args stay lvalues, rvalue args stay rvalues
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

// ── WRONG version — std::move unconditionally strips lvalue-ness ─────────────
template <typename T, typename... Args>
std::unique_ptr<T> makeUniqueBroken(Args&&... args) {
    // Using std::move here moves from lvalue arguments at the call site!
    return std::unique_ptr<T>(new T(std::move(args)...));
}

int main() {
    std::string sharedPayload = "CONNECT /api/v1 HTTP/1.1";

    std::cout << "── Correct perfect forwarding ──\n";
    // sharedPayload is an lvalue — forward preserves it as lvalue — copy ctor fires
    auto packet1 = makeUnique<NetworkPacket>(sharedPayload, 1);
    std::cout << "  sharedPayload still valid: '" << sharedPayload << "'\n\n";

    std::cout << "── Forward with explicit move — intentional steal ──\n";
    // std::move casts sharedPayload to rvalue before entering makeUnique
    // forward then preserves that rvalue — move ctor fires
    auto packet2 = makeUnique<NetworkPacket>(std::move(sharedPayload), 2);
    std::cout << "  sharedPayload after move: '" << sharedPayload << "' (empty — expected)\n\n";

    std::cout << "── Broken version steals lvalue arguments silently ──\n";
    std::string importantData = "DO NOT STEAL ME";
    auto packet3 = makeUniqueBroken<NetworkPacket>(importantData, 3);
    // importantData has been moved-from! Caller doesn't expect this.
    std::cout << "  importantData after makeUniqueBroken: '" << importantData << "' (STOLEN!)\n";

    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <utility>

struct TraceableString {
    std::string value;

    explicit TraceableString(std::string v) : value(std::move(v)) {}

    TraceableString(TraceableString&& other) noexcept : value(std::move(other.value)) {
        std::cout << "  [Move ctor fired]\n";
    }

    TraceableString(const TraceableString& other) : value(other.value) {
        std::cout << "  [Copy ctor fired — this is expensive!]\n";
    }
};

// ── NRVO candidate: compiler builds result directly in caller's frame ─────────
TraceableString buildMessage_NVROFriendly() {
    TraceableString message("Server started on port 8080");
    message.value += " [OK]";
    return message;  // NRVO applies — no move, no copy
}

// ── NRVO BROKEN by explicit std::move — triggers move ctor unnecessarily ──────
TraceableString buildMessage_NRVOBroken() {
    TraceableString message("Server started on port 8080");
    message.value += " [OK]";
    return std::move(message);  // std::move defeats NRVO — move ctor fires
}

// ── Demonstrating the moved-from contract ────────────────────────────────────
void demonstrateMovedFromState() {
    std::vector<int> sensorReadings = {10, 20, 30, 40, 50};
    std::cout << "  Before move: size=" << sensorReadings.size() << "\n";

    std::vector<int> archive = std::move(sensorReadings);
    // sensorReadings is now in a valid-but-empty state — safe to check, unsafe to read elements
    std::cout << "  After move:  sensorReadings.size()=" << sensorReadings.size()
              << "  archive.size()=" << archive.size() << "\n";

    // Safe: reassigning a moved-from object brings it back to a defined state
    sensorReadings = {99, 100};
    std::cout << "  After reassign: sensorReadings.size()=" << sensorReadings.size() << "\n";
}

// ── Returning std::move from a function parameter — legitimate use ────────────
std::string appendSuffix(std::string base, const std::string& suffix) {
    base += suffix;  // Mutates local copy (base was passed by value — it's ours)
    return base;     // NRVO or implicit move — do NOT write std::move(base) here
}

int main() {
    std::cout << "── NRVO-friendly return (expect no move ctor) ──\n";
    TraceableString msg1 = buildMessage_NVROFriendly();
    std::cout << "  Result: " << msg1.value << "\n\n";

    std::cout << "── NRVO broken by std::move (move ctor fires) ──\n";
    TraceableString msg2 = buildMessage_NRVOBroken();
    std::cout << "  Result: " << msg2.value << "\n\n";

    std::cout << "── Moved-from state demonstration ──\n";
    demonstrateMovedFromState();
    std::cout << "\n";

    std::cout << "── Pass-by-value + return (sink pattern) ──\n";
    std::string endpoint = "wss://api.example.com";
    std::string full = appendSuffix(endpoint, "/ws/v2");
    std::cout << "  endpoint still valid: " << endpoint << "\n";
    std::cout << "  full: " << full << "\n";

    return 0;
}

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

struct Tracker {
    std::string data;
    Tracker(std::string d) : data(std::move(d)) {}
    Tracker(const Tracker&) { std::cout << "Copy constructor called\n"; }
    Tracker(Tracker&&) noexcept { std::cout << "Move constructor called\n"; }
};

int main() {
    const Tracker ct("hello");
    std::cout << "Moving from const object: ";
    Tracker moved = std::move(ct);  // Expect "Copy constructor called"
    return 0;
}

#include <iostream>
#include <type_traits>
#include <memory>
#include <utility>

struct MoveOnly {
    MoveOnly() = default;
    MoveOnly(const MoveOnly&) = delete;
    MoveOnly& operator=(const MoveOnly&) = delete;
    MoveOnly(MoveOnly&&) noexcept = default;
    MoveOnly& operator=(MoveOnly&&) noexcept = default;
};

struct Copyable {
    Copyable() = default;
    Copyable(const Copyable&) { std::cout << "Copy\n"; }
    Copyable& operator=(const Copyable&) { std::cout << "Copy assign\n"; return *this; }
};

// Factory that conditionally enables only for movable types
template<typename T, typename... Args,
         typename = std::enable_if_t<std::is_move_constructible<T>::value>>
std::unique_ptr<T> makeMovable(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

int main() {
    // Compiles: MoveOnly is move constructible
    auto ptr1 = makeMovable<MoveOnly>();
    
    // Compiles: Copyable is move constructible too (implicitly)
    Copyable c;
    auto ptr2 = makeMovable<Copyable>(c);
    
    // The following would fail to compile if uncommented:
    // auto ptr3 = makeMovable<Copyable>(std::move(c)); // OK
    // auto ptr4 = makeMovable<const Copyable>(c); // Fails if Copyable not copyable? 
    
    return 0;
}