Move Semantics

#include <string>
#include <utility>

void take(std::string s) { /* by value */ }
void takeLRef(std::string& s) { /* lvalue ref */ }
void takeRRef(std::string&& s) { /* rvalue ref */ }

std::string a = "hello";
take(a);             // copies a into s
take(std::string("x"));  // temporary, could move-construct s (compiler chooses)

// std::move CASTS to rvalue ref. Doesn't actually move; it tells the next
// operation 'you're allowed to steal from this'.
take(std::move(a));  // moves a into s. a is now in 'moved-from' state.
// a is still a valid object but its contents are unspecified, don't use without reassigning.

class Buffer {
    int* data_;
    size_t size_;
public:
    Buffer(size_t n) : data_(new int[n]), size_(n) {}
    ~Buffer() { delete[] data_; }

    // Move constructor, steal the pointer; null out source
    Buffer(Buffer&& other) noexcept
        : data_(other.data_), size_(other.size_) {
        other.data_ = nullptr;
        other.size_ = 0;
    }

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

    // Disable copy for non-copyable resource
    Buffer(const Buffer&) = delete;
    Buffer& operator=(const Buffer&) = delete;
};