C++ 移动语义与完美转发：从原理到实践，一文读懂

// C++98 风格
std::vector<int> createVector() {
    std::vector<int> v(1000000);
    // ... 填充数据
    return v;  // 发生一次拷贝（理论上 RVO 会优化，但并非总是可行）
}

int&& rref = 42;  // 绑定到纯右值
std::string&& sref = std::string("hello"); // 绑定到临时 string

class Buffer {
public:
    // 拷贝构造（左值）
    Buffer(const Buffer& other) : data(new int[other.size]), size(other.size) {
        std::copy(other.data, other.data + size, data);
    }
    // 移动构造（右值）
    Buffer(Buffer&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }
private:
    int* data;
    size_t size;
};

template<typename T>
typename std::remove_reference<T>::type&& move(T&& t) noexcept {
    return static_cast<typename std::remove_reference<T>::type&&>(t);
}

std::string a = "hello";
std::string b = std::move(a);  // 调用移动构造，a 现在为空

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

template<typename T>
void wrapper(T&& arg) {
    // 如果传入左值 int，T 推导为 int&，arg 类型为 int& && -> int&
    // 如果传入右值 int，T 推导为 int，arg 类型为 int&&
}

template<typename T>
T&& forward(typename std::remove_reference<T>::type& arg) noexcept {
    return static_cast<T&&>(arg);
}

class Logger {
public:
    ~Logger() { flush(); }  // 用户定义析构
    // 编译器不会生成移动构造/赋值，因此拷贝会被使用
};

std::vector<int> getVec() {
    std::vector<int> v;
    // ...
    return std::move(v);  // 阻止了返回值优化，可能反而更慢
}

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

template<typename T>
class RingBuffer {
public:
    explicit RingBuffer(size_t capacity) 
        : cap(capacity), head(0), tail(0), count(0) {
        storage = static_cast<T*>(::operator new(sizeof(T) * cap));
    }

    // 移动构造
    RingBuffer(RingBuffer&& other) noexcept 
        : storage(other.storage), cap(other.cap), 
          head(other.head), tail(other.tail), count(other.count) {
        other.storage = nullptr;
        other.cap = 0;
        other.head = other.tail = other.count = 0;
    }

    // 移动赋值
    RingBuffer& operator=(RingBuffer&& other) noexcept {
        if (this != &other) {
            clear();  // 释放当前资源
            ::operator delete(storage);
            storage = other.storage;
            cap = other.cap;
            head = other.head;
            tail = other.tail;
            count = other.count;
            other.storage = nullptr;
            other.cap = 0;
            other.head = other.tail = other.count = 0;
        }
        return *this;
    }

    // 完美转发 push
    template<typename... Args>
    void emplace(Args&&... args) {
        if (count == cap) throw std::overflow_error("Buffer full");
        new (&storage[tail]) T(std::forward<Args>(args)...);
        tail = (tail + 1) % cap;
        ++count;
    }

    // 移动式 pop（返回右值）
    T pop() {
        if (count == 0) throw std::underflow_error("Buffer empty");
        T value = std::move(storage[head]);
        storage[head].~T();
        head = (head + 1) % cap;
        --count;
        return value;  // NRVO + move
    }

    ~RingBuffer() {
        clear();
        ::operator delete(storage);
    }

    // 禁止拷贝
    RingBuffer(const RingBuffer&) = delete;
    RingBuffer& operator=(const RingBuffer&) = delete;

private:
    void clear() {
        for (size_t i = 0; i < count; ++i) {
            storage[(head + i) % cap].~T();
        }
        count = 0;
        head = tail = 0;
    }

    T* storage;
    size_t cap;
    size_t head, tail, count;
};

template<typename Func, typename... Args>
auto invokeLater(Func&& func, Args&&... args) {
    return std::forward<Func>(func)(std::forward<Args>(args)...);
}