突破编程_C++_C++11新特性（右值引用与移动语义）

1 右值引用

1.1 右值引用的基本概念

右值引用是 C++11 中引入的一个关键特性，它允许程序员显式地将一个表达式标记为右值，从而可以利用移动语义进行优化。在深入探讨右值引用的基本概念之前，首先需要理解左值和右值的概念。

在 C++ 中，每个表达式都可以被分类为左值或右值。左值是指那些可以取地址的表达式，例如变量、数组元素、成员变量等。它们通常出现在赋值符号的左边，因为它们可以被赋值。相反，右值则是指那些不能取地址的表达式，例如字面量、临时变量、表达式求值结果等。它们通常出现在赋值符号的右边，因为它们提供了数据值。

右值引用就是对右值进行引用的类型。它的语法是在变量名前添加两个连续的 “&” 符号，例如 “int&&”。通过右值引用，可以获取右值的引用，并在其上进行修改操作。这在以前是不可能的，因为右值是临时对象，其生命周期很短，不能被持久地修改。

右值引用的主要应用场景是实现移动语义。移动语义允许我们将一个对象的状态“移动”到另一个对象，而不是复制它。这通常涉及将资源（如内存指针、文件句柄等）的所有权从一个对象转移到另一个对象，而不是进行深拷贝。这种操作可以显著提高性能，特别是在处理大型对象时。

1.2 右值引用的定义与语法

（1）定义：

右值引用本质上是一个引用，但它只能绑定到右值上。右值通常是那些临时性的、无法取地址的表达式结果，如字面常量、临时变量、函数返回值等。因此，右值引用提供了一种能够直接操作这些临时对象的方式，而无需进行复制或移动操作。

（2）语法：

右值引用的语法相对简单。在变量类型后面添加两个连续的“&&”符号即可表示一个右值引用。例如：

int&& rvalueRef = 10; // 正确：10是右值，可以被右值引用绑定

然而，需要注意的是，不能将一个左值（即有名字的、可以取地址的对象）直接绑定到一个右值引用上，除非使用 std::move 函数将其转换为右值。例如：

int x = 10;  
int&& rvalueRef = x; // 错误：x是左值，不能直接绑定到右值引用上  
int&& rvalueRef = std::move(x); // 正确：使用 std::move 将 x 转换为右值

在上面的例子中，std::move函数并不真正移动任何东西，它只是将其参数转换为右值引用，从而允许将其绑定到一个右值引用上。然而，一旦将一个对象转换为右值引用并进行了某些操作（如移动构造或移动赋值），那么原对象的状态将变得未定义，因此在使用 std::move 时需要格外小心。

1.3 右值引用与左值引用的区别

右值引用与左值引用在 C++ 中都是引用的类型，但它们之间存在显著的差异，主要体现在所引用的对象、生命周期以及使用场景上。

（1）首先，左值引用和右值引用所引用的对象类型不同。

左值引用是对左值的引用，左值指的是有确定的内存地址、有名字的变量，它们可以被赋值，可以在多条语句中使用。而右值引用则是对右值的引用，右值指的是没有名字的临时变量，如字面常量和临时变量，它们不能被赋值，只能在一条语句中出现。简而言之，左值引用是对持久性对象的引用，而右值引用是对临时性对象的引用。

（2）其次，这两种引用的生命周期也有所不同。

左值引用的对象在程序运行期间持续存在，其生命周期与程序的控制流相关。而右值引用的对象，其生命周期通常较短，它们往往是在表达式求值过程中产生的临时对象，一旦表达式执行完毕，这些临时对象就会被销毁。

（3）再者，右值引用和左值引用在使用场景上也有很大的区别。

左值引用主要用于给左值取别名，也就是给已存在的对象一个新的名字，方便在代码中引用它。而右值引用则主要用于实现移动语义，即将资源（如内存、文件句柄等）的所有权从一个对象转移到另一个对象，而非进行传统的深拷贝操作。通过右值引用，可以避免不必要的资源复制，提高程序的性能。

（4）最后，需要注意的是，const 左值引用可以引用左值或右值。
这是因为 const 保证了引用不会修改所引用的对象，从而避免了潜在的风险。而普通的右值引用只能引用右值，不能引用左值，这是由 C++ 的语法规则决定的。

2 移动语义

2.1 移动语义的概念

移动语义（Move Semantics）是 C++11 中引入的一种新的语言特性，旨在提高程序的性能和资源管理效率。其核心概念在于允许对象间资源的转移，而非传统的拷贝操作。

在传统的 C++ 中，对象拷贝涉及数据的复制和资源的分配，这对于大型对象来说，可能会造成不必要的浪费和占用。移动语义通过右值引用（Rvalue Reference）和移动构造函数（Move Constructor）实现了资源的所有权从一个对象到另一个对象的转移，从而避免了不必要的复制操作。

具体来说，右值引用允许标识临时对象或可以被移动的对象。当一个对象即将被销毁（例如，作为函数返回的临时对象或即将离开其作用域的局部变量）时，就可以使用右值引用来引用它，并调用其移动构造函数来转移其资源。移动构造函数接收一个右值引用参数，并将其资源“移动”到新的对象中，而不是复制这些资源。这样，原对象的资源就被新对象接管，而原对象则处于有效但未定义的状态，通常不再使用。

移动语义的实现依赖于有效的资源管理类，例如智能指针和容器类。这些类具备合适的移动构造函数和移动赋值运算符，以确保资源的正确转移和释放。

通过引入移动语义，C++ 程序员能够更高效地管理资源和处理对象，提供了一种全新的编程范式。这有助于减少不必要的内存分配和释放操作，降低程序的运行开销，提高程序的性能。

2.2 移动构造函数

移动构造函数是 C++11 引入的一个新特性，用于实现对象的移动语义。它允许在创建新对象时，从一个临时或即将被销毁的对象中“移动”资源，而不是进行传统的复制操作。这种机制可以显著提高程序的性能和资源管理效率。

移动构造函数的定义形式如下：

ClassName(ClassName&& other);

这里的 ClassName&& 表示一个右值引用参数，意味着这个函数只能接受一个右值作为参数。右值通常指的是临时对象或即将被销毁的对象，它们不再需要原来的资源。

移动构造函数的主要任务是接管另一个对象的资源，并将其置于新创建的对象中。这通常通过交换两个对象的内部指针或直接转移资源的所有权来实现。移动构造完成后，原对象通常处于有效但未定义的状态，它的资源已经被新对象接管，因此不应再被使用。

移动构造函数的使用场景主要包括：

（1）函数返回值传递： 当函数返回一个临时对象时，通过移动构造函数可以避免不必要的拷贝操作。移动构造允许直接转移临时对象的资源给调用者，而不需要复制整个对象。

（2）容器插入操作： 在容器（如std::vector）中插入临时对象时，可以通过移动构造函数实现高效插入。这避免了复制大对象时可能导致的性能开销。

（3）资源管理： 在涉及大量资源分配和释放的场景中，移动构造函数可以显著减少不必要的内存分配和释放操作，提高性能。

下面是一个简单的移动构造函数的例子：

#include <iostream>  
#include <cstring>  

class MyString {
public:
	MyString(const char* str) : data_(new char[strlen(str) + 1]) {
		strcpy(data_, str);
		std::cout << "Copy constructor called." << std::endl;
	}

	// 移动构造函数  
	MyString(MyString&& other) noexcept : data_(other.data_) {
		other.data_ = nullptr;
		std::cout << "Move constructor called." << std::endl;
	}

	~MyString() {
		delete[] data_;
	}

	// 禁止拷贝赋值和移动赋值，以保持简单示例  
	MyString& operator=(const MyString&) = delete;
	MyString& operator=(MyString&&) = delete;

private:
	char* data_;
};

int main() 
{
	std::cout << "create str1" << std::endl;
	MyString str1("Hello, world!");
	std::cout << "create str2" << std::endl;
	MyString str2(std::move(str1)); // 这里会调用移动构造函数  
	return 0;
}

上面代码的输出为：

create str1
Copy constructor called.
create str2
Move constructor called.

在上面的例子中，当构造函数的入参为 std::move(str1) 时，编译器会自动选择移动构造函数来构造 str2，从而避免了不必要的拷贝操作。

需要注意的是，移动构造函数应该被标记为 noexcept（如果确实不会抛出异常），这样可以保证在移动操作失败时不会造成资源泄露或其他问题。此外，移动构造函数通常还会将原对象的资源指针设为 nullptr，以避免悬挂指针问题。

2.3 移动赋值运算符

移动赋值运算符是 C++11 引入的一个新特性，它允许从一个对象中“移动”资源到另一个对象，而不是进行传统的复制操作。这种机制对于提升性能、优化资源管理至关重要。

移动赋值运算符的基本语法如下：

ClassName& operator=(ClassName&& other) noexcept;

这里的 ClassName&& 表示一个右值引用参数，意味着这个函数只能接受一个右值（即临时对象或即将被销毁的对象）作为参数。noexcept 关键字表示该操作不会抛出异常，这有助于编译器进行更好的优化。

移动赋值运算符的主要任务是从源对象（other）中“窃取”资源，并将其置于当前对象中。这通常通过交换两个对象的内部状态来实现，或者简单地通过移动源对象的资源到当前对象，并将源对象的资源置为空或进行清理。

移动赋值运算符通常按照以下步骤工作：

（1）检查自赋值： 首先，检查当前对象（*this）是否就是源对象（other）。如果是，则直接返回当前对象的引用，以避免自赋值问题。

（2）释放当前对象的资源： 释放当前对象所持有的资源，以防止资源泄露。这可能涉及删除动态分配的内存、关闭文件句柄等操作。

（3）移动源对象的资源： 将源对象的资源（如指针、句柄等）转移到当前对象中。这通常涉及简单的赋值操作，因为源对象之后将不再需要这些资源。

（4）置空源对象的资源： 将源对象的资源指针或句柄置为nullptr或相应的无效状态，确保源对象在析构时不会尝试释放已经移动的资源。

（5）返回当前对象的引用： 返回当前对象的引用，以便支持链式赋值操作。

移动赋值运算符的一个关键优点是它避免了不必要的复制操作，特别是在处理大型对象或资源密集型对象时。通过移动而不是复制资源，可以显著提高程序的性能。

需要注意的是，一旦一个对象的资源被移动，该对象就处于有效但未定义的状态。这意味着它仍然是一个有效的对象，但其内部状态是未知的，因此不应再被使用，除非被重新赋值或重新初始化。

此外，移动赋值运算符通常与移动构造函数一起使用，以提供完整的移动语义支持。编译器在适当的情况下会自动生成移动赋值运算符和移动构造函数，但也可以根据需要自定义它们。

下面是一个简单的移动构造函数的例子：

#include <iostream>  
#include <cstring>  

class MyString {
public:
	MyString() {}
	MyString(const char* str) : data_(new char[strlen(str) + 1]) {
		strcpy(data_, str);
		std::cout << "Copy constructor called." << std::endl;
	}

	// 移动赋值函数  
	MyString& operator=(MyString&& other) noexcept {
		if (this != &other) {
			// 释放当前对象的资源  
			delete[] data_;

			data_ = other.data_;
			other.data_ = nullptr;
			std::cout << "Move constructor called." << std::endl;
		}
		return *this;
	}

	~MyString() {
		delete[] data_;
	}


private:
	char* data_ = nullptr;
};

int main() 
{
	std::cout << "create str1" << std::endl;
	MyString str1("Hello, world!");
	std::cout << "create str2" << std::endl;
	MyString str2; // 不可以直接写成 MyString str2 = std::move(str1); 此时调用的还是移动构造函数，而不是移动赋值函数（这里由于没有定义移动构造函数，所以会编译失败）
	str2 = std::move(str1); // 这里会调用移动赋值函数  
	return 0;
}

上面代码的输出为：

create str1
Copy constructor called.
create str2
Move constructor called.

3 右值引用与移动语义的实际应用

3.1 自定义类型中的移动语义

在 C++ 中，当需要传递或返回大的自定义类型对象时，如果采用传统的值传递方式，会涉及到对象的拷贝操作，这可能会导致不必要的性能开销。移动语义则允许我们将一个对象的资源“移动”到另一个对象，而不是进行拷贝，从而避免了不必要的开销。

要实现移动语义，需要定义移动构造函数和移动赋值运算符。移动构造函数接受一个右值引用（rvalue reference）作为参数，这个右值引用通常是一个临时对象或者是一个即将被销毁的对象。移动构造函数会“移动”这个右值引用对象的资源（如动态分配的内存、文件句柄等），然后将其置于有效的未定义状态。这样，就不需要再对这个右值引用对象进行任何操作，因为它已经不再拥有这些资源了。

类似地，移动赋值运算符也接受一个右值引用作为参数，并将右侧对象的资源移动到左侧对象。与移动构造函数不同的是，移动赋值运算符在移动资源之前需要处理左侧对象原有的资源，以避免资源泄漏。这通常涉及到释放左侧对象原有的资源，然后再移动右侧对象的资源。

通过定义移动构造函数和移动赋值运算符，可以让自定义类型支持移动语义。这样，在需要传递或返回大的自定义类型对象时，编译器可以自动选择使用移动操作而不是拷贝操作，从而提高程序的性能。

需要注意的是，移动语义并不总是比拷贝语义更优。在某些情况下，拷贝操作可能更简单、更安全。因此，在定义移动构造函数和移动赋值运算符时，需要仔细考虑它们是否真的能够提高程序的性能，并且确保它们不会引入新的问题或错误。

注意：移动语义的本质是根据传入的右值引用类型调用移动构造函数或者移动赋值运算符！

如下为样例代码（实际上是综合了上面章节中的样例代码）：

#include <iostream>  
#include <cstring>  

class MyString {
public:
	// 构造函数  
	MyString(const char* str) {
		length = strlen(str);
		data = new char[length + 1];
		strcpy(data, str);

		std::cout << "MyString(const char* str)" << std::endl;
	}

	// 移动构造函数  
	MyString(MyString&& other) noexcept : data(other.data), length(other.length) {
		// 将原对象的数据指针设为nullptr，防止其析构时再次释放  
		other.data = nullptr;
		other.length = 0;

		std::cout << "MyString(MyString&& other) noexcept : data(other.data), length(other.length)" << std::endl;
	}

	// 析构函数  
	~MyString() {
		delete[] data;
	}

	// 拷贝构造函数（为了完整性）  
	MyString(const MyString& other) {
		length = other.length;
		data = new char[length + 1];
		strcpy(data, other.data);

		std::cout << "MyString(const MyString& other)" << std::endl;
	}

	// 拷贝赋值运算符（为了完整性）  
	MyString& operator=(const MyString& other) {
		if (this != &other) {
			delete[] data;
			length = other.length;
			data = new char[length + 1];
			strcpy(data, other.data);
		}

		std::cout << "MyString& operator=(const MyString& other)" << std::endl;

		return *this;
	}

	// 移动赋值运算符  
	MyString& operator=(MyString&& other) noexcept {
		if (this != &other) {
			delete[] data;
			data = other.data;
			length = other.length;
			other.data = nullptr;
			other.length = 0;
		}

		std::cout << "MyString& operator=(MyString&& other) noexcept" << std::endl;

		return *this;
	}

	// 打印字符串  
	void print() const {
		std::cout << data << std::endl;
	}

private:
	char* data;
	size_t length;

};

int main() 
{
	// 创建一个MyString对象  
	MyString s1("Hello");

	// 使用移动构造函数创建一个新对象  
	MyString s2 = std::move(s1); // s1现在处于有效但未定义状态  

	// 打印s2（应该输出"Hello"）  
	s2.print();

	// 尝试使用s1（不允许，因为s1现在处于未定义状态）  
	// s1.print(); // 可能会导致未定义行为  

	// 使用移动赋值运算符  
	MyString s3("World");
	s2 = std::move(s3); // s3现在处于有效但未定义状态  

	// 打印s2（应该输出"World"）  
	s2.print();

	return 0;
}

上面代码的输出为：

MyString(const char* str)
MyString(MyString&& other) noexcept : data(other.data), length(other.length)
Hello
MyString(const char* str)
MyString& operator=(MyString&& other) noexcept
World

在这个示例中，String 类管理了一个动态分配的字符数组。它定义了移动构造函数和移动赋值运算符，这些构造函数和运算符将资源的所有权从一个 String 对象移动到另一个对象，而不是进行拷贝。在移动操作之后，原对象（在本例中是 other）处于有效但未定义的状态，因此不能再使用。

noexcept 关键字用于标记这些操作不会抛出异常，这允许编译器在更多情况下优化代码。

3.2 函数返回值优化与移动语义

函数返回值优化（Return Value Optimization，简称 RVO）和移动语义都是 C++ 中用于提高性能的重要技术，它们各自在资源管理和对象创建方面扮演着关键角色。

函数返回值优化是 C++ 编译器的一项优化技术，用于减少对象在返回时的拷贝操作。当函数返回一个对象时，传统的做法是在函数内部创建一个临时对象，然后通过拷贝构造函数将这个临时对象拷贝到调用者那里。然而，这种做法涉及不必要的资源拷贝和对象创建，可能导致性能下降。

为了解决这个问题，编译器会尝试进行 RVO 优化。在优化过程中，编译器会尝试直接在调用者的栈帧上构造返回对象，而不是在函数内部创建临时对象后再进行拷贝。这样，就可以避免不必要的拷贝操作，提高性能。

值得注意的是，虽然 RVO 是编译器的优化行为，但为了确保优化的有效性，程序员在编写代码时也应该遵循一些最佳实践。例如，避免在函数内部创建不必要的临时对象，确保返回的对象类型与函数返回类型一致等。

在实际应用中，这两种技术往往可以相互补充。当编译器进行 RVO 优化时，它可能会利用移动语义来更有效地管理资源。例如，在返回对象时，如果编译器决定直接在调用者的栈帧上构造对象，那么它可能会使用移动语义来“窃取”函数内部临时对象的资源，而不是进行传统的拷贝操作。

（1）RVO

结合 “3.1 自定义类型中的移动语义” 样例代码中创建的 MyString 类型，做如下 RVO 的测试：

// class MyString 的定义，这里不再重复

// 返回一个String对象的函数  
MyString createString(const char* str) {
	return MyString(str); // 这里可能发生RVO  
}

int main() 
{
	// 调用createString函数并接收返回的String对象  
	MyString s = createString("Hello, World!");

	// 打印返回的String对象  
	s.print();

	return 0;
}

上面代码的输出为：

MyString(const char* str)
Hello, World!

如果编译器进行了 RVO 优化，将只会看到 “MyString(const char* str)”的输出，而不会看到 “MyString(const MyString& other)” 的输出，因为实际上没有发生拷贝操作。

（2）移动语义

继续使用 “3.1 自定义类型中的移动语义” 样例代码中创建的 MyString 类型，做如下移动语义的测试：

// class MyString 的定义，这里不再重复

// 返回一个String对象的函数  
MyString createString(const char* str) {
	MyString s = str;
	return s; // 这里会自动调用移动语义，也可以写成 std::move(s);   
}

int main() 
{
	// 调用createString函数并接收返回的String对象  
	MyString s = createString("Hello, World!");

	// 打印返回的String对象  
	s.print();

	return 0;
}

上面代码的输出为：

MyString(const char* str)
MyString(MyString&& other) noexcept : data(other.data), length(other.length)
Hello, World!

3.3 STL 容器中的移动语义

STL（Standard Template Library）容器中的移动语义是 C++11 引入的一个重要特性，它允许我们更加高效地处理容器中的对象，特别是在涉及到对象所有权转移的场景中。移动语义通过避免不必要的拷贝操作，显著提高了代码的性能。

在 C++ 中，传统的对象复制操作（如拷贝构造函数和拷贝赋值运算符）涉及创建对象的完整副本，这可能会消耗大量的时间和内存资源。然而，在某些情况下，实际上并不需要创建对象的副本，而只是需要将一个对象的资源（如动态分配的内存）转移到另一个对象。这就是移动语义发挥作用的地方。

STL容器中的移动语义主要体现在以下几个方面：

• 移动构造函数和移动赋值运算符：STL容器中的许多类型都定义了移动构造函数和移动赋值运算符。这些特殊成员函数允许容器在需要时，通过“窃取”另一个对象的资源来初始化或赋值给当前对象，而不是进行传统的复制操作。这种资源转移的方式通常更加高效。
• 插入和赋值操作：在STL容器中插入或赋值对象时，如果提供了右值引用（rvalue reference）作为参数，容器就可以利用移动语义来避免不必要的拷贝。例如，使用 std::vector 的 push_back 方法时，如果传递的是一个临时对象或即将被移动的对象（右值），则vector会使用移动构造函数或移动赋值运算符来添加元素，而不是进行拷贝。
• 容器间的元素转移：STL 提供了一些函数和算法，用于在容器之间高效地转移元素。例如，std::move 函数可以用于将一个容器中的元素移动到另一个容器中，而不需要进行任何拷贝操作。此外，std::swap 函数在 C++11 之后也利用了移动语义，以便在交换两个对象时更加高效。
  下面是一个简单的示例，演示了如何在 STL 容器中使用移动语义：

#include <iostream>  
#include <vector>  
#include <string>  
  
int main() 
{  
    // 创建一个包含字符串的vector  
    std::vector<std::string> vec1 = {"Hello", "World"};  
  
    // 使用移动语义将 vec1 中的元素移动到 vec2 中  
    std::vector<std::string> vec2(std::make_move_iterator(vec1.begin()), std::make_move_iterator(vec1.end()));  
    vec1.clear(); // 清空 vec1，因为元素已经被移动  
  
    // 输出 vec2 中的元素，与 vec1 原来的元素相同，而 vec1 则为空
    for (const auto& str : vec2) {  
        std::cout << str << std::endl;  
    }  
  
    return 0;  
}

这个示例使用了 std::make_move_iterator 来创建移动迭代器，这些迭代器允许将 vec1 中的元素移动到 vec2 中，而不需要进行任何拷贝操作。这样，就可以高效地转移容器中的元素，同时减少内存使用和性能开销。