C++11右值引用与移动语义：从深拷贝到资源转移的实战理解

有几个点值得留意：移动操作最好标记 noexcept，否则标准库容器在扩容时可能不敢用移动而退化为拷贝。另外，移动后源对象处于'有效但未定义'状态，通常我们会把它置为空（如 nullptr），这样析构时不会重复释放。

std::move 只是类型转换

std::move 不做任何移动，它只是把参数转换为右值引用，让重载决议选择移动版本。真正搬资源的是那个接受右值引用的函数（构造或赋值）。因此，如果你写了 std::move(some_obj)，但接收方并没有移动构造，那还是拷贝。

拷贝消除与返回值优化

从函数返回局部对象时，现代编译器往往会直接构造到调用方的接收变量上，连移动都省了。如果你用的是 C++17 或更高，返回值优化在某些情况下甚至是强制的。想观察原始行为，可以加 -fno-elide-constructors 编译选项关闭优化。

实战：给链表加上右值感知

来看一个加了移动语义的双向链表。重点是 push_back 能根据传入的是左值还是右值，分别调用拷贝或移动，从而在插入临时对象时避免额外拷贝。

先看节点定义：

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)) {}
};

这里节点为泛型 T 提供了左值拷贝构造和右值移动构造。注意右值版本里用 std::move(x) 来调用 T 自身的移动构造，而不是拷贝。

链表类的 push_back 提供了两个重载：

void push_back(const T& x) { insert(end(), x); }
void push_back(T&& x) { insert(end(), std::move(x)); }

这样，当你写 list.push_back("some long string") 时，"some long string" 会被隐式转为临时 T 对象，触发移动版本的 push_back，最终在插入节点时用移动构造，只转移资源，没有深拷贝。

为了看得更清楚，我用一个带日志的自定义 string 来测试（完整代码见后）。注意它的移动构造和移动赋值里都打印了信息，方便观察调用时机。

namespace Alice {
class string {
    // ... 构造函数打印信息 ...
    string(string&& s) noexcept {
        cout << "string(string&&)-移动构造" << endl;
        swap(s);
    }
    string& operator=(string&& s) noexcept {
        cout << "string=移动赋值" << endl;
        swap(s);
        return *this;
    }
    // ...
};
}

然后这样使用：

jqj::list<Alice::string> lt;
Alice::string s1("111111111111111111");

lt.push_back(s1);                     // 左值，调用拷贝构造
lt.push_back("22222222222222222222"); // 右值（临时对象），移动构造
lt.push_back("33333333333333333333"); // 同样移动
lt.push_back(move(s1));               // 显式移动，之后 s1 不应再使用

运行程序，你能看到清晰的构造、拷贝、移动日志。这个例子也提醒我们：一旦显式 std::move 了一个左值，就不要再碰它了，除非重新赋予新值。

完整的链表实现（含迭代器等）参见下面的代码块。

// 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 <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));

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

实际工作中，你不需要每次都手写这样的链表；标准库容器如 std::vector、std::string 已经广泛支持移动语义。理解原理有助于你在设计自己的资源管理类时，写出高效且正确的代码。另外，移动语义和完美转发经常搭配使用，比如在工厂函数或包装器中，可以用 std::forward 无损传递参数的左右值属性。

以上，右值引用并不神秘。关键是分清楚什么时候对象能安全地移交资源，并确保移动操作不抛异常。这样能让编译器更智能地优化你的程序，减少昂贵的深拷贝。