C++ 右值语义详解：从基础到实战

Last updated on December 12, 2024 pm

C++ 右值语义详解：从基础到实战

在现代 C++ 中，右值语义是一个非常重要的概念，它涉及到右值引用、移动语义、完美转发等核心特性。本文将结合代码实例，详细讲解与右值语义相关的所有知识点，帮助你全面掌握这一主题。

1. 左值与右值的基本概念

1.1 左值 (Lvalue)

左值是可以取地址的表达式，通常表示一个对象或变量。左值具有持久性，可以被赋值。

#include <iostream>

int main() {
    int a = 10; // 'a' 是一个左值
    std::cout << "Address of a: " << &a << std::endl; // 可以取地址
    return 0;
}

1.2 右值 (Rvalue)

右值是不能取地址的表达式，通常是临时对象或字面量。右值具有短暂性，不能被赋值。

#include <iostream>

int main() {
    int&& r = 42; // '42' 是一个右值
    // std::cout << "Address of 42: " << &42 << std::endl; // 错误：不能取地址
    return 0;
}

1.3 纯右值 (PRvalue) 与将亡值 (Xvalue)

纯右值：临时对象或字面量，如 42、std::string("hello")。
将亡值：即将被销毁的对象，通常是右值引用的结果，如 std::move(x)。

2. 右值引用 (Rvalue Reference)

2.1 右值引用的语法

右值引用使用 T&& 语法，表示对右值的引用。

#include <iostream>

int main() {
    int&& r = 42; // 右值引用
    std::cout << "r = " << r << std::endl;
    return 0;
}

2.2 右值引用的作用

右值引用主要用于支持移动语义和完美转发。

3. 移动语义 (Move Semantics)

3.1 移动构造函数 (Move Constructor)

移动构造函数接受一个右值引用参数，用于将资源从一个对象“移动”到新对象。

#include <iostream>
#include <vector>

class MyVector {
public:
    std::vector<int> data;

    // 移动构造函数
    MyVector(MyVector&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Move Constructor called" << std::endl;
    }

    MyVector(const std::vector<int>& d) : data(d) {}
};

int main() {
    MyVector v1{std::vector<int>{1, 2, 3}};
    MyVector v2 = std::move(v1); // 调用移动构造函数
    return 0;
}

3.2 移动赋值运算符 (Move Assignment Operator)

移动赋值运算符接受一个右值引用参数，用于将资源从一个对象“移动”到现有对象。

#include <iostream>
#include <vector>

class MyVector {
public:
    std::vector<int> data;

    // 移动赋值运算符
    MyVector& operator=(MyVector&& other) noexcept {
        if (this != &other) {
            data = std::move(other.data);
            std::cout << "Move Assignment Operator called" << std::endl;
        }
        return *this;
    }

    MyVector(const std::vector<int>& d) : data(d) {}
};

int main() {
    MyVector v1{std::vector<int>{1, 2, 3}};
    MyVector v2{std::vector<int>{4, 5, 6}};
    v2 = std::move(v1); // 调用移动赋值运算符
    return 0;
}

3.3 `std::move`

std::move 将一个左值转换为右值引用，以便调用移动构造函数或移动赋值运算符。

#include <iostream>
#include <vector>

class MyVector {
public:
    std::vector<int> data;

    MyVector(MyVector&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Move Constructor called" << std::endl;
    }

    MyVector(const std::vector<int>& d) : data(d) {}
};

int main() {
    MyVector v1{std::vector<int>{1, 2, 3}};
    MyVector v2 = std::move(v1); // 使用 std::move 调用移动构造函数
    return 0;
}

4. 完美转发 (Perfect Forwarding)

4.1 问题背景

在模板编程中，如何将参数的值类别（左值或右值）保持不变地传递给其他函数。

4.2 `std::forward`

std::forward 在模板中保持参数的值类别，实现完美转发。

#include <iostream>
#include <utility>

void print(int& x) {
    std::cout << "Lvalue: " << x << std::endl;
}

void print(int&& x) {
    std::cout << "Rvalue: " << x << std::endl;
}

template <typename T>
void wrapper(T&& arg) {
    print(std::forward<T>(arg)); // 完美转发
}

int main() {
    int a = 10;
    wrapper(a);  // 调用 print(int&)
    wrapper(20); // 调用 print(int&&)
    return 0;
}

4.3 引用折叠 (Reference Collapsing)

引用折叠规则：

T& & 折叠为 T&
T& && 折叠为 T&
T&& & 折叠为 T&
T&& && 折叠为 T&&

5. 特殊成员函数与规则

5.1 特殊成员函数

移动构造函数：ClassName(ClassName&&);
移动赋值运算符：ClassName& operator=(ClassName&&);

5.2 编译器生成的移动操作

如果用户显式定义了拷贝构造函数、拷贝赋值运算符或析构函数，编译器不会自动生成移动操作。

#include <iostream>

class NoMove {
public:
    NoMove() = default;
    NoMove(const NoMove&) { std::cout << "Copy Constructor" << std::endl; }
    NoMove& operator=(const NoMove&) { std::cout << "Copy Assignment" << std::endl; return *this; }
};

int main() {
    NoMove a;
    NoMove b = std::move(a); // 调用拷贝构造函数，因为移动操作未生成
    return 0;
}

5.3 删除的移动操作

如果移动操作被显式删除或不可访问，对象将无法移动。

#include <iostream>

class DeletedMove {
public:
    DeletedMove() = default;
    DeletedMove(DeletedMove&&) = delete; // 显式删除移动构造函数
};

int main() {
    DeletedMove a;
    // DeletedMove b = std::move(a); // 错误：移动构造函数被删除
    return 0;
}

6. 右值语义的应用场景

6.1 资源管理类

在自定义的资源管理类中，使用移动语义避免不必要的资源拷贝。

#include <iostream>
#include <memory>

class Resource {
public:
    std::unique_ptr<int> ptr;

    Resource(int value) : ptr(std::make_unique<int>(value)) {}

    Resource(Resource&& other) noexcept : ptr(std::move(other.ptr)) {
        std::cout << "Resource moved" << std::endl;
    }
};

int main() {
    Resource r1(42);
    Resource r2 = std::move(r1); // 移动资源
    return 0;
}

6.2 标准库中的右值语义

std::unique_ptr、std::vector 等标准库容器和智能指针广泛使用右值语义。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v1{1, 2, 3};
    std::vector<int> v2 = std::move(v1); // 移动 vector
    std::cout << "v2 size: " << v2.size() << std::endl;
    return 0;
}

6.3 函数返回值优化 (RVO) 与移动语义

在函数返回值时，编译器可能使用 RVO 或移动语义优化性能。

#include <iostream>
#include <vector>

std::vector<int> createVector() {
    std::vector<int> v{1, 2, 3};
    return v; // 可能触发 RVO 或移动语义
}

int main() {
    std::vector<int> v = createVector();
    std::cout << "v size: " << v.size() << std::endl;
    return 0;
}

7. 常见问题与注意事项

7.1 移动后对象的状态

移动后的对象处于有效但未定义的状态，通常不应再使用。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v1{1, 2, 3};
    std::vector<int> v2 = std::move(v1);
    // v1.size(); // 未定义行为，v1 已被移动
    return 0;
}

7.2 避免不必要的 `std::move`

在返回局部变量时，编译器会自动选择移动或拷贝，无需显式调用 std::move。

#include <iostream>
#include <vector>

std::vector<int> createVector() {
    std::vector<int> v{1, 2, 3};
    return std::move(v); // 不必要的 std::move
}

int main() {
    std::vector<int> v = createVector();
    std::cout << "v size: " << v.size() << std::endl;
    return 0;
}

7.3 右值引用的陷阱

右值引用本身是左值，因此需要使用 std::move 或 std::forward 来保持其右值特性。

#include <iostream>

void print(int&& x) {
    std::cout << "Rvalue: " << x << std::endl;
}

int main() {
    int&& r = 42;
    // print(r); // 错误：r 是左值
    print(std::move(r)); // 正确
    return 0;
}

8.为什么需要右值

在 C++ 中，右值（Rvalue）是一个非常重要的概念，它的引入主要是为了解决以下几个核心问题：

8.1 避免不必要的拷贝

在传统的 C++ 中，对象的拷贝操作可能会带来性能问题，尤其是在处理大对象或资源密集型对象时。例如，当你将一个对象从一个地方移动到另一个地方时，如果使用拷贝操作，会浪费大量的时间和资源。

例子：

#include <iostream>
#include <vector>

std::vector<int> createVector() {
    std::vector<int> v{1, 2, 3, 4, 5};
    return v; // 返回局部对象
}

int main() {
    std::vector<int> v = createVector(); // 拷贝构造
    std::cout << "v size: " << v.size() << std::endl;
    return 0;
}

在这个例子中，createVector 返回一个局部对象 v，如果编译器没有优化（如 RVO 或 NRVO），那么 v 会被拷贝到 main 中的 v。对于大对象来说，拷贝操作的代价非常高。

右值的引入：通过右值引用和移动语义，可以将对象的资源“移动”到目标对象，而不是拷贝，从而避免不必要的开销。

8.2 支持移动语义

移动语义是 C++11 引入的一个重要特性，它允许将资源从一个对象“移动”到另一个对象，而不是拷贝。移动语义的核心是右值引用（T&&）。

例子：

#include <iostream>
#include <vector>

class MyVector {
public:
    std::vector<int> data;

    // 移动构造函数
    MyVector(MyVector&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Move Constructor called" << std::endl;
    }

    MyVector(const std::vector<int>& d) : data(d) {}
};

int main() {
    MyVector v1{std::vector<int>{1, 2, 3}};
    MyVector v2 = std::move(v1); // 调用移动构造函数
    return 0;
}

在这个例子中，v1 的资源被“移动”到 v2，而不是拷贝。移动操作的代价非常低，通常只是指针的交换。

8.3 支持完美转发

在模板编程中，函数参数的值类别（左值或右值）可能会丢失，导致无法正确地传递参数。完美转发（Perfect Forwarding）通过右值引用和 std::forward 解决了这个问题。

例子：

#include <iostream>
#include <utility>

void print(int& x) {
    std::cout << "Lvalue: " << x << std::endl;
}

void print(int&& x) {
    std::cout << "Rvalue: " << x << std::endl;
}

template <typename T>
void wrapper(T&& arg) {
    print(std::forward<T>(arg)); // 完美转发
}

int main() {
    int a = 10;
    wrapper(a);  // 调用 print(int&)
    wrapper(20); // 调用 print(int&&)
    return 0;
}

在这个例子中，wrapper 函数能够正确地转发参数的值类别，无论是左值还是右值。

8.4 优化资源管理

在资源管理类（如智能指针、文件句柄等）中，右值引用和移动语义可以显著提高性能。例如，std::unique_ptr 是一个典型的例子，它只能通过移动语义来传递所有权，而不能拷贝。

例子：

#include <iostream>
#include <memory>

class Resource {
public:
    std::unique_ptr<int> ptr;

    Resource(int value) : ptr(std::make_unique<int>(value)) {}

    Resource(Resource&& other) noexcept : ptr(std::move(other.ptr)) {
        std::cout << "Resource moved" << std::endl;
    }
};

int main() {
    Resource r1(42);
    Resource r2 = std::move(r1); // 移动资源
    return 0;
}

在这个例子中，std::unique_ptr 的资源被移动到 r2，而不是拷贝。这确保了资源的唯一所有权。

8.5 提高代码的表达能力

右值引用的引入使得 C++ 的表达能力更强。通过移动语义和完美转发，开发者可以编写更高效、更简洁的代码。例如，标准库中的容器（如 std::vector）和算法（如 std::sort）都广泛使用了右值语义。

例子：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> v1{1, 2, 3};
    std::vector<int> v2 = std::move(v1); // 移动 vector
    std::cout << "v2 size: " << v2.size() << std::endl;
    return 0;
}

在这个例子中，v1 的资源被移动到 v2，而不是拷贝。这使得代码更加高效。

8.6 解决临时对象的资源浪费

在传统的 C++ 中，临时对象（如函数返回值）的生命周期很短，但它们的资源可能会被浪费。通过右值引用和移动语义，可以有效地利用这些临时对象的资源。

例子：

#include <iostream>
#include <vector>

std::vector<int> createVector() {
    std::vector<int> v{1, 2, 3};
    return v; // 返回局部对象
}

int main() {
    std::vector<int> v = createVector(); // 可能触发 RVO 或移动语义
    std::cout << "v size: " << v.size() << std::endl;
    return 0;
}

在这个例子中，createVector 返回的临时对象 v 的资源被移动到 main 中的 v，而不是拷贝。

9.总结

右值的引入解决了以下几个核心问题：

避免不必要的拷贝：通过移动语义，减少大对象或资源密集型对象的拷贝开销。
支持移动语义：允许将资源从一个对象“移动”到另一个对象，而不是拷贝。
支持完美转发：在模板编程中，保持参数的值类别，确保参数能够正确传递。
优化资源管理：在智能指针和资源管理类中，确保资源的唯一所有权。
提高代码的表达能力：使代码更加高效、简洁。
解决临时对象的资源浪费：利用临时对象的资源，避免浪费。

通过右值引用和移动语义，C++ 的性能和表达能力得到了显著提升，使得现代 C++ 代码更加高效和现代化。

公众号

开发 > cpp

#c++ #cpp

C++ 右值语义详解：从基础到实战

https://chongzicbo.github.io/2024/12/12/开发/cpp/C++001：C++右值语义详解：从基础到实战/

Author

程博

Posted on

December 12, 2024

Licensed under

C++ 常量详解 Previous

Python 日志处理最佳实践：使用loguru模块构建高效日志系统 Next

C++ 右值语义详解：从基础到实战

C++ 右值语义详解：从基础到实战

1. 左值与右值的基本概念

1.1 左值 (Lvalue)

1.2 右值 (Rvalue)

1.3 纯右值 (PRvalue) 与将亡值 (Xvalue)

2. 右值引用 (Rvalue Reference)

2.1 右值引用的语法

2.2 右值引用的作用

3. 移动语义 (Move Semantics)

3.1 移动构造函数 (Move Constructor)

3.2 移动赋值运算符 (Move Assignment Operator)

3.3 std::move

4. 完美转发 (Perfect Forwarding)

4.1 问题背景

4.2 std::forward

4.3 引用折叠 (Reference Collapsing)

5. 特殊成员函数与规则

5.1 特殊成员函数

5.2 编译器生成的移动操作

5.3 删除的移动操作

6. 右值语义的应用场景

6.1 资源管理类

6.2 标准库中的右值语义

6.3 函数返回值优化 (RVO) 与移动语义

7. 常见问题与注意事项

7.1 移动后对象的状态

7.2 避免不必要的 std::move

7.3 右值引用的陷阱

8.为什么需要右值

8.1 避免不必要的拷贝

例子：

8.2 支持移动语义

例子：

8.3 支持完美转发

例子：

8.4 优化资源管理

例子：

8.5 提高代码的表达能力

例子：

8.6 解决临时对象的资源浪费

例子：

9.总结

3.3 `std::move`

4.2 `std::forward`

7.2 避免不必要的 `std::move`