C++11 右值引用与移动语义详解：从性能瓶颈到零拷贝优化

引用折叠与生命周期

右值引用不仅可以绑定右值，还可以用于延长临时对象的生命周期。值得注意的是，右值引用变量本身在表达式中表现为左值。这意味着如果你有一个右值引用变量，再次使用时它会被视为左值，除非显式调用 std::move。

int&& rr = 10;
rr = 20; // 合法，因为 rr 是左值

移动语义与右值引用

为什么需要移动？

传统的拷贝构造和拷贝赋值会深拷贝资源（如堆内存），对于包含大对象（如 std::string, std::vector）的类来说，开销巨大。移动语义允许我们将资源的所有权从一个对象转移到另一个对象，而无需分配新内存或复制数据。

移动构造函数与赋值运算符

移动构造函数要求第一个参数为右值引用。如果存在其他参数，必须有默认值。

class MyString {
public:
    // 移动构造
    MyString(MyString&& other) noexcept 
        : _str(other._str), _size(other._size) {
        other._str = nullptr; // 窃取资源后清空原对象
        other._size = 0;
    }

    // 移动赋值
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] _str;
            _str = other._str;
            _size = other._size;
            other._str = nullptr;
            other._size = 0;
        }
        return *this;
    }
private:
    char* _str;
    size_t _size;
};

传值返回与拷贝消除

在函数返回局部对象时，传统上会发生两次拷贝（局部对象 -> 临时对象 -> 返回值）。现代编译器通常会应用拷贝消除（Copy Elision）优化，甚至直接构造返回值对象，避免临时对象产生。

为了验证是否发生移动而非拷贝，可以使用 -fno-elide-constructors 编译选项关闭优化。

实战：自定义链表与右值引用

下面是一个简化的双向链表实现，展示了如何利用右值引用优化 push_back 操作。

list.h

#pragma once
#include <algorithm>
#include <initializer_list>

namespace jqj {

template<class T>
struct list_node {
    list_node<T>* _next;
    list_node<T>* _prev;
    T _data;

    // 左值构造
    list_node(const T& x = T()) :_next(nullptr), _prev(nullptr), _data(x) {}
    // 右值构造
    list_node(T&& x) :_next(nullptr), _prev(nullptr), _data(std::move(x)) {}
};

template<class T, class Ref, class Ptr>
struct list_iterator {
    using Self = list_iterator<T, Ref, Ptr>;
    using Node = list_node<T>;
    Node* _node;

    list_iterator(Node* node) :_node(node) {}

    Ref operator*() { return _node->_data; }
    Ptr operator->() { return &_node->_data; }

    Self& operator++() { _node = _node->_next; return *this; }
    Self operator++(int) { Self tmp(*this); _node = _node->_next; return tmp; }
    Self& operator--() { _node = _node->_prev; return *this; }
    Self operator--(int) { Self tmp(*this); _node = _node->_prev; return tmp; }

    bool operator!=(const Self& s) const { return _node != s._node; }
    bool operator==(const Self& s) const { return _node == s._node; }
};

template<class T>
class list {
    using Node = list_node<T>;
public:
    using iterator = list_iterator<T, T&, T*>;
    using const_iterator = list_iterator<T, const T&, const T*>;

    iterator begin() { return iterator(_head->_next); }
    iterator end() { return iterator(_head); }
    const_iterator begin() const { return const_iterator(_head->_next); }
    const_iterator end() const { return const_iterator(_head); }

    void empty_init() {
        _head = new Node;
        _head->_next = _head;
        _head->_prev = _head;
    }

    list() { empty_init(); }

    list(std::initializer_list<T> il) {
        empty_init();
        for (auto& e : il) push_back(e);
    }

    ~list() { clear(); delete _head; _head = nullptr; }

    void swap(list<T>& lt) {
        std::swap(_head, lt._head);
        std::swap(_size, lt._size);
    }

    void clear() {
        iterator it = begin();
        while (it != end()) it = erase(it);
    }

    // 左值插入
    void push_back(const T& x) { insert(end(), x); }
    // 右值插入
    void push_back(T&& x) { insert(end(), std::move(x)); }

    void insert(iterator pos, const T& x) {
        Node* cur = pos._node;
        Node* prev = cur->_prev;
        Node* newnode = new Node(x);
        prev->_next = newnode;
        newnode->_prev = prev;
        newnode->_next = cur;
        cur->_prev = newnode;
        ++_size;
    }

    iterator erase(iterator pos) {
        Node* cur = pos._node;
        Node* prev = cur->_prev;
        Node* next = cur->_next;
        prev->_next = next;
        next->_prev = prev;
        delete cur;
        --_size;
        return next;
    }

    size_t size() const { return _size; }

private:
    Node* _head;
    size_t _size = 0;
};
}

Test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <vector>
#include <map>
#include <string>
#include "list.h"

using namespace std;

namespace Alice {
class string {
public:
    typedef char* iterator;
    typedef const char* const_iterator;

    iterator begin() { return _str; }
    iterator end() { return _str + _size; }
    const_iterator begin() const { return _str; }
    const_iterator end() const { return _str + _size; }

    string(const char* str) :_size(strlen(str)), _capacity(_size) {
        cout << "string(char* str)-构造" << endl;
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }

    void swap(string& s) {
        std::swap(_str, s._str);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
    }

    string(const string& s) {
        cout << "string(const string&)-拷贝构造" << endl;
        reserve(s._capacity);
        for (auto ch : s) push_back(ch);
    }

    string(string&& s) noexcept {
        cout << "string(string&&)-移动构造" << endl;
        swap(s);
    }

    string& operator=(const string& s) {
        cout << "string=拷贝赋值" << endl;
        if (this != &s) {
            delete[] _str;
            _str = nullptr;
            _size = 0;
            reserve(s._capacity);
            for (auto ch : s) push_back(ch);
        }
        return *this;
    }

    string& operator=(string&& s) noexcept {
        cout << "string=移动赋值" << endl;
        swap(s);
        return *this;
    }

    ~string() {
        delete[] _str;
        _str = nullptr;
    }

    char& operator[](size_t pos) {
        return _str[pos];
    }

    void reserve(size_t new_capacity) {
        if (new_capacity > _capacity) {
            char* tmp = new char[new_capacity + 1];
            if (_str) {
                strcpy(tmp, _str);
                delete[] _str;
            }
            _str = tmp;
            _capacity = new_capacity;
        }
    }

    void push_back(char ch) {
        if (_size >= _capacity) {
            size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
            reserve(newcapacity);
        }
        _str[_size] = ch;
        ++_size;
        _str[_size] = '\0';
    }

    string& operator+=(char ch) {
        push_back(ch);
        return *this;
    }

    const char* c_str() const { return _str; }
    size_t size() const { return _size; }

private:
    char* _str = nullptr;
    size_t _size = 0;
    size_t _capacity = 0;
};
}

int main() {
    jqj::list<Alice::string> lt;
    cout << "**************************" << endl;

    Alice::string s1("111111111111111111");
    lt.push_back(s1); // 左值，触发拷贝构造

    cout << "**************************" << endl;
    lt.push_back("2222222222222222222222222222222222"); // 临时对象，触发移动构造

    cout << "**************************" << endl;
    lt.push_back("3333333333333333333333333333333"); // 临时对象，触发移动构造

    cout << "**************************" << endl;
    lt.push_back(move(s1)); // 显式移动，s1 之后不可再用

    cout << "**************************" << endl;
    return 0;
}

总结

右值引用和移动语义是 C++11 提升性能的关键特性。通过区分左值和右值，我们可以精确控制资源的转移方式。在实际开发中，合理使用 std::move 和重载移动构造函数，结合编译器的拷贝消除优化，能够显著减少不必要的内存分配和数据复制，特别是在处理大型数据结构时效果明显。