18、移动语义与左值引用：左值引用与右值引用的重载决议、移动语义与 const 引用的交互、引用限定符

这一章，我们来聊聊引用之间的「爱恨情仇」。左值引用、右值引用、const 引用，它们凑在一起时，编译器到底听谁的？移动语义和 const 引用之间又有什么微妙的关系？嗯，这些坑我当年都踩过，今天一并说清楚。

18.1 左值引用与右值引用的重载决议

先看一个最基础的问题：当你写了一个函数，同时提供左值引用和右值引用的重载版本，编译器怎么选？

void process(int& lref) {
    std::cout << "左值引用版本\n";
}

void process(int&& rref) {
    std::cout << "右值引用版本\n";
}

int main() {
    int x = 42;
    process(x);           // 调用左值引用版本
    process(100);         // 调用右值引用版本
    process(std::move(x)); // 调用右值引用版本
}

结果很直观：左值走左值版本，右值走右值版本。但这里有个细节——std::move(x) 返回的是 int&&，所以它匹配右值引用版本。说白了，std::move 就是个「身份转换器」，它不移动任何东西，只是告诉编译器：「嘿，请把这个值当作右值来处理」。

我在项目中遇到过一个问题：有人写了三个重载——void f(T&)、void f(const T&) 和 void f(T&&)。结果传左值时，编译器优先选了 T& 而非 const T&。为什么？因为非 const 引用更匹配非 const 左值。这其实很合理——你想想看，如果传进来的是一个可修改的对象，编译器当然倾向于给你一个可修改的引用。

18.2 移动语义与 const 引用的交互

这里有个大坑，我当年栽过跟头。

class Buffer {
    char* data_;
    size_t size_;
public:
    Buffer(const Buffer& other) 
        : size_(other.size_)
    {
        data_ = new char[size_];
        std::copy(other.data_, other.data_ + size_, data_);
        std::cout << "拷贝构造\n";
    }
    
    Buffer(Buffer&& other) noexcept
        : data_(other.data_), size_(other.size_)
    {
        other.data_ = nullptr;
        other.size_ = 0;
        std::cout << "移动构造\n";
    }
};

void process_buffer(const Buffer& buf) {
    // 这里只能拷贝，不能移动
    Buffer local = buf;  // 调用拷贝构造！
}

int main() {
    Buffer b(1024);
    process_buffer(std::move(b)); // 你以为会移动？不，还是拷贝！
}

为什么会这样？因为 process_buffer 的参数是 const Buffer&，即使你传入了右值，它也被绑定到了 const 左值引用上。而 Buffer local = buf 中，buf 是 const 左值引用，不能匹配移动构造（移动构造需要非 const 右值引用），所以只能走拷贝构造。

我曾经在写一个日志系统时犯过这个错。我把所有参数都写成 const std::string&，结果大量临时字符串对象无法被移动，性能惨不忍睹。后来改成按值传递 + std::move，吞吐量直接翻倍。

18.3 引用限定符

C++11 引入了一个不太起眼但非常实用的特性——引用限定符（Reference Qualifiers）。它允许你根据对象是左值还是右值，来重载成员函数。

class Widget {
    std::vector<int> data_;
public:
    // 左值对象调用
    const std::vector<int>& get_data() const & {
        return data_;
    }
    
    // 右值对象调用
    std::vector<int> get_data() && {
        return std::move(data_);
    }
};

Widget make_widget() {
    return Widget{};
}

int main() {
    Widget w;
    auto& ref = w.get_data();        // 调用 const & 版本，返回引用
    auto val = make_widget().get_data(); // 调用 && 版本，移动数据
}

这个模式非常有用。你想想看，如果对象是临时右值，它的内部资源反正要销毁了，不如直接移走，省一次拷贝。而左值对象我们通常不想破坏它，所以返回 const 引用更安全。

引用限定符的语法很简单：在函数声明后面加上 & 或 &&。注意，const 限定符和引用限定符可以同时使用，顺序是 const & 或 const &&（虽然 const 右值引用很少用）。

18.4 重载决议中的引用限定符

当引用限定符和 const 限定符组合时，重载决议的规则稍微复杂一些。来看个例子：

class Example {
public:
    void foo() & { std::cout << "左值版本\n"; }
    void foo() && { std::cout << "右值版本\n"; }
    void foo() const & { std::cout << "const 左值版本\n"; }
    void foo() const && { std::cout << "const 右值版本\n"; }
};

int main() {
    Example e;
    const Example ce;
    
    e.foo();           // 左值版本
    std::move(e).foo(); // 右值版本
    ce.foo();          // const 左值版本
    std::move(ce).foo(); // const 右值版本
}

编译器会根据调用对象的 value category 和 const 属性，选择最匹配的版本。这里有个细节：std::move(ce) 返回 const Example&&，所以它匹配 const && 版本。

18.5 知识体系总览

下面这张图总结了本章的核心逻辑：

这张图展示了三个核心概念的关系：左值/右值引用是基础，重载决议决定调用哪个版本，const 引用会阻碍移动语义，而引用限定符则提供了更精细的控制手段。

18.6 避坑指南

最后，分享几个我亲身踩过的坑：

• 不要对 const 对象使用 std::move：std::move(const_obj) 返回 const T&&，这不会触发移动构造，只会调用拷贝构造。我曾经以为这样能「骗」过编译器，结果白白浪费了半天调试时间。
• 引用限定符不能用于静态成员函数：静态函数没有 this，自然没有左值/右值之分。编译器会直接报错。
• 小心 && 限定符的成员函数返回内部资源：如果你在 && 版本中返回了内部指针或引用，而调用者把它存了下来，那么临时对象销毁后，这个引用就悬空了。嗯，这属于典型的「搬起石头砸自己的脚」。

好了，这一章的内容就到这里。引用重载决议、const 引用的陷阱、引用限定符——这三者组合起来，构成了 C++ 移动语义中非常精妙的一部分。理解它们，你就能写出更高效、更安全的代码。

---

公众号:蓝海资料掘金营，微信deep3321