Move Semantics

int x = 5;       // x is an lvalue; 5 is an rvalue
int y = x + 3;   // x+3 is an rvalue (temporary)

void f(int& ref);       // binds to lvalues
void f(int&& ref);      // binds to rvalues (rvalue reference)

f(x);       // calls f(int&)
f(5);       // calls f(int&&)
f(x + 3);   // calls f(int&&)

class Buffer {
    uint8_t* data_;
    size_t   size_;
public:
    // Constructor
    explicit Buffer(size_t size)
        : data_(new uint8_t[size]), size_(size) {}

    // Destructor
    ~Buffer() { delete[] data_; }

    // Copy — expensive: allocates + copies bytes
    Buffer(const Buffer& other)
        : data_(new uint8_t[other.size_]), size_(other.size_) {
        std::memcpy(data_, other.data_, size_);
    }

    // Move constructor — cheap: steals pointer, O(1)
    Buffer(Buffer&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;   // leave source in valid but empty state
        other.size_ = 0;
    }

    // Move assignment
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data_;          // free current resource
            data_ = other.data_;
            size_ = other.size_;
            other.data_ = nullptr;
            other.size_ = 0;
        }
        return *this;
    }
};

// Mark move operations noexcept!
// std::vector uses move instead of copy during reallocation
// ONLY if the move constructor is noexcept.
// Without noexcept, vector falls back to copying — losing the speedup.
Buffer(Buffer&&) noexcept;            // vector will use move: fast
Buffer(Buffer&&) /* no noexcept */;   // vector uses copy: slow

std::vector<int> a = {1, 2, 3, 4, 5};

// Copy: a still valid, b is a deep copy
std::vector<int> b = a;
std::cout << a.size();  // 5

// Move: b steals a's buffer, a is empty
std::vector<int> c = std::move(a);
std::cout << a.size();  // 0 (valid but unspecified state)
std::cout << c.size();  // 5

// 1. Return from function — NRVO usually handles this,
//    but explicit move is sometimes needed
std::vector<int> build_data() {
    std::vector<int> result;
    // ... fill result ...
    return result;   // compiler applies RVO automatically
}

// 2. Pass unique_ptr (non-copyable — must move)
void take_device(std::unique_ptr<IDevice> dev);

auto d = std::make_unique<UartDevice>();
take_device(std::move(d));   // transfer ownership
// d == nullptr now

// 3. Store a string in a struct without copying
struct Packet {
    std::string name;
    std::vector<uint8_t> data;
};
std::string s = "temperature";
Packet p { std::move(s), {} };  // s is empty now; no copy

std::string s = "hello";
std::string t = std::move(s);
// s is valid — you can reassign it
s = "world";  // OK
std::cout << s;  // "world"

template <typename T>
void wrapper(T arg) {
    inner(arg);        // arg is always an lvalue inside the function!
}

std::string s = "hello";
wrapper(s);                  // inner sees lvalue — OK
wrapper(std::string("hi"));  // inner sees lvalue, NOT rvalue — loses move!

// T&& in a deduced context is a "universal reference" (not just rvalue ref)
template <typename T>
void wrapper(T&& arg) {
    inner(std::forward<T>(arg));  // forward preserves value category
}

wrapper(s);                   // T = string&  → forwards as lvalue
wrapper(std::string("hi"));   // T = string   → forwards as rvalue

template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
// Arguments forwarded to T's constructor with correct value category

// Named Return Value Optimisation (NRVO)
std::vector<int> build() {
    std::vector<int> result;   // named local
    result.push_back(1);
    result.push_back(2);
    return result;             // compiler builds 'result' directly in caller
}                              // no copy, no move — zero cost

auto v = build();  // v IS the result object (constructed in place)

// When NRVO doesn't apply (multiple return paths):
std::vector<int> build2(bool flag) {
    std::vector<int> a, b;
    // fill a and b ...
    return flag ? a : b;  // NRVO can't apply — return std::move(a/b) here
}