深入理解C++11右值引用与移动语义：高效编程的基石

suye

发布于 2024-11-21 17:14:30

12900

代码可运行

文章被收录于专栏：17的博客分享17的博客分享

运行总次数：0

代码可运行

前言

在现代C++编程中，性能优化和资源管理一直是开发者追求的目标。C++11引入的右值引用（rvalue reference）和移动语义（move semantics）为解决这些问题提供了强有力的工具。通过右值引用，我们能够更高效地处理临时对象；而移动语义的引入，则进一步优化了对象的资源转移和管理。在这篇文章中，我们将深入探索右值引用和移动语义的核心概念、实现原理，以及它们在实际开发中的应用场景。

📚一、C++11的历史发展

C++11 是 C++ 标准的一次重大更新，于 2011 年发布。它引入了许多新的特性和改进，使得 C++ 更加现代化、高效且易于使用。C++11 的发布可以说是 C++ 语言的一次**“复兴”**，在过去几十年中，标准化组织（ISO）对 C++ 语言的不断完善起到了重要作用。

📖1.1 C++11 之前的背景

在 C++11 之前，C++ 的最新标准是 C++98 和它的技术修正（C++03）。C++98 于 1998 年发布，建立了 C++ 的基础特性，如模板、标准模板库（STL）、异常处理等。C++03 是对 C++98 的一些小修订，主要是修复了 C++98 中的缺陷，并未引入新的语言特性。随着计算机硬件的快速发展和软件开发需求的变化，C++98 和 C++03 逐渐显得陈旧，无法满足更高效、更现代化的软件开发需求。

📖1.2 C++11 的发展历程

C++11 的标准化过程可以追溯到 2002 年。C++ 标准委员会（ISO/IEC JTC1/SC22/WG21）开始对 C++ 语言进行改进的讨论，目标是让 C++ 语言更加高效和现代化，同时保持其核心的性能和灵活性。在这个过程中，多个 C++ 提案被提出，委员会从这些提案中选取了对语言发展最为重要的部分进行标准化。经过近 10 年的讨论和修改，最终在 2011 年发布了 C++11 标准。

📖1.3 C++11 的主要设计目标

C++11 的设计目标主要包括以下几个方面：

提高程序性能和效率：为了解决大型项目中的性能瓶颈，C++11 引入了移动语义、智能指针、多线程支持等特性。
改进编程体验：C++11 提供了许多语法改进，使得代码更简洁清晰，如自动类型推导（auto）、范围 for 循环、初始化列表等。
增强可移植性和可维护性：通过标准库的扩展和新功能，C++11 提供了更好的跨平台支持和更高的代码可维护性。

📖1.4 C++11 的主要特性

C++11 引入了大量新特性，使得 C++ 语言得到了显著的改进。以下是一些主要特性：

右值引用和移动语义：通过右值引用（T&&）和 std::move 实现移动语义，优化了资源管理和对象拷贝。
自动类型推导：auto 关键字可以自动推导变量类型，使代码更加简洁。
智能指针：std::shared_ptr、std::unique_ptr 和 std::weak_ptr 解决了原始指针的内存管理问题。
Lambda 表达式：引入了 Lambda 表达式，使得 C++ 具备了更现代化的函数式编程能力。
多线程支持：标准库引入了 std::thread、std::mutex 等多线程工具，为并发编程提供了标准化的支持。
新容器：如 std::unordered_map 和 std::array 等，丰富了 C++ 的数据结构。
范围 for 循环：更简洁的循环语法，便于遍历容器。
constexpr：引入 constexpr 关键字支持编译时常量计算，提升了程序的执行效率。
初始化列表：统一的初始化语法，提供了更灵活的初始化方式。
空指针常量：引入 nullptr 代替原来的 NULL，避免类型不安全的问题。
静态断言：static_assert 允许在编译期进行断言检查，提高了代码的健壮性。

📖1.5 C++11 的影响

C++11 的发布使得 C++ 语言变得更加强大和现代化，成为工业级开发的主流选择之一。以下是 C++11 的主要影响：

编程范式的改变：C++11 引入了许多现代化的语法和特性，使得编程范式从传统的面向对象逐渐向更简洁和高效的函数式编程发展。
提高了开发效率：通过更简洁的语法和自动化的内存管理工具（如智能指针），C++11 提高了开发效率，降低了代码复杂度。
促进了后续标准的制定：C++11 的成功促使标准委员会在此基础上继续改进，推出了 C++14、C++17、C++20 和 C++23，使 C++ 语言保持了活力和竞争力。

📚二、统一的列表初始化

在 C++11 中，列表初始化（List Initialization）是一种新的初始化方式，它允许使用花括号 {} 来初始化变量和对象。这种方式提供了更一致和灵活的初始化方法，避免了一些潜在的错误。列表初始化主要有以下几种形式：

📖2.1 基本列表初始化

最常见的列表初始化形式是直接用 {} 初始化变量或对象。这种方式可以应用于内置类型、类类型和数组。

int a{5};             // a 初始化为 5
double b{3.14};       // b 初始化为 3.14
int arr[3]{1, 2, 3};  // 初始化数组

📖2.2 使用初始化列表初始化 STL 容器

C++11 允许通过列表初始化来直接构造 STL 容器。

#include <vector>
#include <iostream>
using namespace std;

int main() {
    vector<int> vec{1, 2, 3, 4}; // 使用列表初始化向量
    for (int val : vec) {
        cout << val << " ";      // 输出: 1 2 3 4
    }
    return 0;
}

📖2.3 类构造函数中的列表初始化

C++11 引入了 std::initializer_list，使得可以通过列表初始化构造类对象。为此，类需要实现接受 std::initializer_list 的构造函数。

#include <initializer_list>
#include <iostream>
using namespace std;

class MyClass {
public:
    MyClass(initializer_list<int> list) {
        for (auto val : list) {
            cout << val << " ";
        }
        cout << endl;
    }
};

int main() {
    MyClass obj{1, 2, 3, 4}; // 使用列表初始化
    return 0;
}

在这个例子中，MyClass 接受一个 std::initializer_list<int> 类型的参数，可以在初始化时传入多个值。

📖2.4 列表初始化防止隐式窄化转换

列表初始化可以防止某些类型转换错误（例如浮点数到整数的窄化转换），从而提高代码的安全性。C++11 标准规定，列表初始化不允许隐式的窄化转换。

int x{3.14}; // 错误：3.14 是 double，不能隐式转换为 int

上面代码会报错，因为 3.14 是 double 类型，而列表初始化不允许将 double 隐式转换为 int。

📖2.5 默认初始化

通过列表初始化，可以直接实现默认初始化：使用 {} 直接初始化，没有提供具体值。

int x{};         // x 初始化为 0
double y{};      // y 初始化为 0.0
std::string s{}; // s 初始化为空字符串

📖2.6 聚合类型的列表初始化

对于聚合类型（如数组、struct），可以使用列表初始化为其成员赋值。

多参数构造函数的隐式类型转换

struct Point {
    Point(int x, int y)
		:_x(x)
		,_y(y)
	{}
    
    int _x;
    int _y;
};

Point p{10, 20}; // 使用列表初始化 struct 成员

explicit关键字避免隐式类型转换带来的不确定性

struct Point {
    explicit Point(int x, int y)
		:_x(x)
		,_y(y)
	{}
    
    int _x;
    int _y;
};

Point p{10, 20}; // 会报错

📚三、`decltype`——编译时获取表达式的类型

📖3.1 如何声明一个未知类型变量

总所周知，在C++98之中有这样一个运算符名叫typeid，它可以查看任何变量或者函数的类型，例如：

int main() {
	int i = 10;
	auto p = &i;
	auto pf = malloc;

	cout << typeid(p).name() << endl;
	cout << typeid(pf).name() << endl;
    
    return 0;
}

很显然，typeid推出的类型只能看不能用，当然你也可以将其打印出来，再确定它的类型之后手动声明或定义新变量，不过这样未免显得有点太繁琐。于是我们想到经常使用的auto关键字：

int i = 10;
auto p = &i;	// 只能定义变量

可以发现，使用auto必须要给左值添加一个右值，用来推导类型，可有些时候我们只想声明，先不想赋值该怎么办？C++11推出了一个新的关键字叫做decltype，用于在编译时获取表达式的类型。它允许开发者在不显式指定类型的情况下获取变量或表达式的类型信息，从而提高代码的灵活性和可维护性。

基本用法

decltype 的基本语法是 decltype(expression)，其中 expression 是一个有效的 C++ 表达式或者变量。编译器会分析表达式或者变量的类型，并将其作为 decltype 的结果类型。

示例

int main() {
	auto pf = malloc;
	decltype(pf) pf2;
	cout << typeid(pf2).name() << endl;
    
    return 0;
}

📖3.2 获取自定义类的成员函数类型

decltype 可以用于获取类成员变量的类型，这在使用模板和泛型编程时非常有用。

template<class Func>
class B{
private:
	Func _f;
};

int main() {
	auto pf = malloc;
	B<decltype(pf)> b1;
	cout << "b1->type:" << typeid(b1).name() << endl;

	const int x = 1;
	double y = 2.2;

	B<decltype(x * y)> b2;
	cout << "b2->type:" << typeid(b2).name() << endl;

	return 0;
}

📚四、左、右值引用和移动语义

📖4.1 什么是左值，右值？

在C++中，左值（Lvalue）和右值（Rvalue）是表达式类型的重要概念。它们决定了表达式的“值类别”，即表达式的结果可以用于什么类型的操作，比如赋值、地址取用等。

📒1. 左值（Lvalue）

左值（Lvalue，Locator value）是一个可以取地址的表达式，表示一个持久的、可命名的存储位置。它可以出现在赋值运算符的左边，也就是说，它是可以被赋值的对象。

特点：具有持久性，可多次访问。
示例：变量、数组元素、解引用的指针等。
用法：左值通常用于表示可以被修改的对象，但需要注意的是，有些左值可能是const的，即使是左值也不能修改。

示例

int x = 10;   // x 是一个左值，可以赋值
int* p = &x;  // 可以取 x 的地址

在这里，x就是左值，因为我们可以取它的地址并在后续操作中多次使用它。

📒2. 右值（Rvalue）

右值（Rvalue，Read value）是一个不持久的、临时的值，通常是表达式的结果。它不能取地址，通常出现在赋值的右侧。右值通常是字面量、临时对象或是表达式的计算结果，不能重复使用。

特点：通常为临时值，只在表达式中短暂存在。
示例：字面量（如10）、表达式如（x + y）、临时对象。
用法：右值不能直接取地址，不能在后续操作中重复使用，除非绑定到右值引用。

示例

int y = 5 + 3; // 5 + 3 是一个右值
int z = y * 2; // y * 2 是一个右值

这里，5 + 3 和 y * 2是右值，它们是表达式的计算结果，不能取地址。

📒3. 左值和右值的主要区别

特性	左值（Lvalue）	右值（Rvalue）
持久性	是持久性的	是临时性的
可赋值性	可以出现在赋值运算符的左边	通常不能出现在赋值的左边
取地址	可以取地址	不能取地址
用途	可多次访问的对象	通常为表达式结果或临时值(将亡值)

📖4.2 左值引用和右值引用

在C++中，左值引用和右值引用是两种不同的引用类型，主要用于资源管理、性能优化和控制对象的生命周期。它们分别是为左值（持久对象）和右值（临时对象）设计的。

📒1. 左值引用（Lvalue Reference）

左值引用（T&）是C++中最常见的引用类型，用于引用变量、对象等持久化的左值，通常用于需要在多个地方访问和修改同一对象的情况。

定义：T&，例如int& ref = x;
绑定对象：左值引用只能绑定到左值上，如变量、数组元素等。
典型用途：
- 传递和修改函数参数。
- 提高效率，避免函数参数的拷贝。
- 提供统一的接口来操作对象。

示例

void updateValue(int& ref) {
    ref = 20; // 修改原始对象
}

int main() {
    int x = 10;
    updateValue(x); // 传递左值引用，直接修改 x
    cout << x; // 输出 20
}

在这个例子中，updateValue函数使用左值引用来修改传入的参数x，避免了不必要的拷贝。

📒2. 右值引用（Rvalue Reference）

右值引用（T&&）是C++11引入的一种新型引用类型，用于绑定到右值（如临时对象或表达式的计算结果）。右值引用允许在编程中直接使用和操作临时对象，是实现移动语义的关键。

定义：T&&，例如int&& rref = 5;
绑定对象：右值引用只能绑定到右值（临时值）上，比如常量、表达式结果，函数的传值返回值（不能是左值引用返回值）等。
典型用途：
- 实现移动语义：右值引用可以通过转移资源而非复制资源，来优化程序性能。
- 避免不必要的拷贝：右值引用允许在需要生成临时对象的地方避免对象拷贝，从而提高效率。

示例：实现移动语义

class MyClass {
public:
    int* data;
    
    MyClass() : data(new int[1000]) {}
    
    // 移动构造函数
    MyClass(MyClass&& other) : data(other.data) {
        other.data = nullptr;  // 转移资源
    }
    
    ~MyClass() { delete[] data; }
};

MyClass createMyClass() {
    MyClass temp;
    return temp; // 返回右值，触发移动构造
}

在这里，createMyClass函数返回一个临时对象（右值），可以通过移动构造函数实现资源转移，避免拷贝，从而提高性能。

📒3. 左值引用与右值引用的区别

特性	左值引用（T&）	右值引用（T&&）
绑定对象	只能绑定到左值	只能绑定到右值
常见用途	函数参数传递和修改、避免拷贝	移动语义、转移资源所有权、优化性能
示例	int& ref = x;	int&& rref = 5 + 3;
用法限制	不能绑定右值	不能直接绑定左值，需std::move转换

📒4. 左值引用能否给右值取别名?

在C++中，左值引用不能直接绑定到右值。通常情况下，左值引用（T&）只能绑定到左值，而不是右值。右值是临时的、短暂存在的值，而左值引用需要绑定到一个持久的、可以命名的对象，因此不能直接给右值取别名。

间接方式：通过 const 左值引用绑定右值

不过，const左值引用（const T&）可以绑定到右值。这是因为 const 左值引用不会修改绑定对象的值，允许在函数中引用临时对象或字面量等右值。使用 const T& 可以间接为右值取别名。

示例

void print(const int& ref) {
    cout << ref << endl;
}

int main() {
    print(10);  // 10 是右值，但可以绑定到 const int& 上
}

在这个例子中，字面量 10 是右值，但可以通过 const int& 引用传递给 print 函数。通过这种方式，可以间接地为右值取一个别名。

📒5. 右值引用能否给左值取别名?

右值引用不能直接给左值取别名。右值引用（T&&）的设计初衷是用于绑定右值（即临时对象）来实现移动语义。因此，右值引用只能绑定到右值，不能直接绑定到左值。

但是：通过 std::move 可以实现

如果希望将左值转化为右值引用，可以使用 std::move 将左值转换成右值来绑定到右值引用。std::move 不会真正移动数据，只是将左值“视为”右值，以便能够绑定到右值引用。

示例

void process(int&& rref) {
     cout << "Processing value: " << rref << endl;
}

int main() {
    int x = 10;          // x 是一个左值
    process(move(x)); 	// 将 x 转换为右值引用，可以绑定到 int&&
}

在这个例子中，std::move(x)将左值x转换为右值引用，从而能够绑定到右值引用参数rref上。

为什么右值引用不直接绑定左值

右值引用的目的是为了避免拷贝，通过资源转移提升效率，而左值通常是需要继续使用的持久对象，不适合绑定到右值引用（右值引用的绑定会引导资源转移，导致左值状态不可预测）。因此设计上不允许右值引用直接绑定左值，除非明确使用 std::move 来告知编译器。

📒总结

左值引用只能引用左值，不能引用右值
但是const左值引用既可以引用左值，也可以引用右值
右值引用只能引用右值，不能引用左值
但是右值引用可以引用move以后的左值

📖4.3 右值引用的使用场景和意义

在 C++11 中，为了提高程序的性能，增加了移动构造函数和移动赋值运算符，它们使对象的资源可以从一个对象“移动”到另一个对象，而不是进行深拷贝。这样可以显著减少不必要的内存分配和复制，尤其是对于动态分配资源的类（如包含指针的类）而言。

📒1. 移动构造函数

移动构造函数的作用是通过“移动”资源来构造一个新对象，而不是“复制”资源。这意味着，资源的所有权将从源对象转移到目标对象，而源对象在移动后通常会处于“空”或“无效”的状态，但仍然可析构。

移动构造函数的定义使用右值引用 &&，通常在构造函数声明中使用以下形式：

class MyClass {
public:
    MyClass(MyClass&& other) noexcept;  // 移动构造函数
};

假设我们有一个简单的类 MyClass，包含一个动态分配的数组指针：

#include <iostream>
#include <string>
using namespace std;

class MyClass {
public:
    string data;

    // 普通构造函数
    MyClass(const string& str) : data(str) {}

    // 移动构造函数
    MyClass(string&& str) noexcept : data(move(str)) {
        cout << "Move constructor called\n";
    }
};

int main() {
    string temp = "Hello";
    MyClass obj(move(temp));  // 调用移动构造函数
    cout << "temp after move: " << temp << endl;  // temp 可能为空
    return 0;
}

在上面的例子中，std::move(temp) 将 temp 转换为右值，触发移动构造函数，将 temp 的资源移动到 obj 中。这避免了深拷贝，提高了效率。

输出结果：

📒2. 移动赋值运算符

移动赋值运算符用于在赋值操作中转移资源的所有权。它通常用于将一个临时对象或不再需要的对象的资源“移动”到另一个已存在的对象上。

移动赋值运算符同样使用右值引用 &&，并返回当前对象的引用 *this：

class MyClass {
public:
    MyClass& operator=(MyClass&& other) noexcept;  // 移动赋值运算符
};

在前面的 MyClass 基础上，我们可以实现移动赋值运算符：

class MyClass {
public:
    string data;

    // 普通构造函数
    MyClass(const string& str) : data(str) {}

    // 移动构造函数
    MyClass(string&& str) noexcept : data(move(str)) {
        cout << "Move constructor called\n";
    }
    
    // 移动赋值运算符重载
    MyClass& operator=(MyClass&& other) noexcept {
    if (this != &other) {
        data = move(other.data);  // 使用 move 将资源移动
        other.data.clear();       // 清空 other 的 data
        cout << "Move Assigned called\n";
    }
    return *this;
}
};

int main() {
    string temp = "Hello";
    MyClass obj(move(temp));  // 调用移动构造函数
	MyClass obj2("World");
	obj = move(obj2);   // 调用移动赋值运算符
	cout << "obj2.data after move: " << obj2.data << endl;  // obj2.data 可能为空
    
    return 0;
}

在这个示例中：

移动赋值运算符首先检查对象是否为自赋值。
如果不是自赋值，则释放当前对象的资源，将 other.data 转移到 this->data，并将 other.data 置空，防止重复释放。

输出结果：

📒3. 为什么要使用 `noexcept`

通常在移动构造函数和移动赋值运算符中添加 noexcept，表示该操作不会抛出异常。这是因为许多标准库容器会检查移动操作是否为 noexcept，以决定是否使用移动操作。

📚五、完美转发

📖5.1 模板中的万能引用`&&`

在C++11的模板编程中，**&&**代表万能引用，既能接收左值，又能接收右值。我们以下面的代码为例，分析一下&& 在模板中的意义：

代码示例：

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

// 万能引用：既可以接收左值，又可以接收右值
template<typename T>
void PerfectForward(T&& t){
	Fun(t);
}
int main(){
	PerfectForward(10); // 右值
	int a;
	PerfectForward(a); // 左值
	PerfectForward(move(a)); // 右值
	const int b = 8;
	PerfectForward(b); // const 左值
	PerfectForward(move(b)); // const 右值

	return 0;
}

注意看，我定义了4个Fun函数，用来判断PerfectForward函数接收的左值或者右值能否在Fun函数中持续左值或者右值的状态。

输出结果：

让人意想不到的是打印出来的竟然全部都是左值引用！这究竟是怎么一回事呢？我们先拿第一行代码PerfectForward(10); 解释一下，PerfectForward 的形参 t 接收了一个右值 10 ，这里是右值引用。不过在函数体中，调用了 Fun(t); 这一语句，**而此时的 t 却是完完全全的一个左值，因为右值引用变量的属性会被编译器识别成左值，否则在移动构造的场景下，无法完成资源转移，必须要修改。**所以 Fun() 函数只会调用 void Fun(int& x) 。main 函数中的其他关于右值的语句也都是犯了这样一个错误，当然左值不受影响。**总的来说，引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值。**为了防止这种错误的大面积发生，C++11做出了相应调整，增加了一个函数模板叫做std::forward<T>，主要用于实现 完美转发（perfect forwarding）。它可以根据参数的类型是左值还是右值，保留参数的值类别（即左值或右值）并转发给另一个函数。

📖5.2 `forward<T>`完美转发

std::forward<T> 的主要作用是保持传入参数的值类别（左值或右值），并正确地转发给接收方函数。它通常用于模板函数中，使得可以处理并转发任意的值类别。它的使用场景是右值引用和模板参数的结合。

对于以上代码我们就可以进行更改啦:

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

template<typename T>
void PerfectForward(T&& t) {
	// t是左值引用，保持左值属性
	// t是右值引用，保持右值属性
	Fun(forward<T>(t));
}
int main() {
	PerfectForward(10); // 右值
	int a;
	PerfectForward(a); // 左值
	PerfectForward(move(a)); // 右值
	const int b = 8;
	PerfectForward(b); // const 左值
	PerfectForward(move(b)); // const 右值

	return 0;
}

输出结果：