【cmu15445c++入门】(2)c++中的std::move() 左值引用右值引用

本文主要是介绍【cmu15445c++入门】(2)c++中的std::move() 左值引用右值引用，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

左值右值

要理解move语义，必须理解左值和右值的概念。左值的简化定义是左值是对象，指向内存中某个位置。右值是左值之外的任何。

std::move()

move语义，在C++中是一个有用的方法，它允许在对象之间高效和优化地转移数据所有权。move语义的主要目标之一是提高性能，因为移动对象比深度复制对象更快、更高效。

std::move 是将对象从一个左值移动到另一个左值的最常见方法。

std::move 将表达式转换为右值。这允许我们将左值作为右值进行交互，并允许所有权从一个左值转移到另一个左值。

代码

/*** @file move_semantics.cpp* @author Abigale Kim (abigalek)* @brief Tutorial code for move semantics.*/// Move semantics in C++ are a useful concept that allows for the efficient
// and optimized transfer of ownership of data between objects. One of the
// main goals of move semantics is to increase performance, since moving an
// object is faster and more efficient than deep copying the object.
// move语义，在C++中是一个有用的方法，它允许在对象之间高效和优化地转移数据所有权。
// move语义的主要目标之一是提高性能，因为移动对象比深度复制对象更快、更高效// To understand move semantics, one must understand the concept of lvalues
// and rvalues. A simplified definition of lvalues is that lvalues are objects
// that refer to a location in memory. Rvalues are anything that is not a
// lvalue.
//要理解move语义，必须理解左值和右值的概念。左值的简化定义是左值是对象，指向内存中某个位置。右值是左值之外的任何。// std::move is the most common way of moving an object from one lvalue to
// another. std::move casts an expression to a rvalue. This allows for us to
// interact with a lvalue as a rvalue, and allows for the ownership to be
// transferred from one lvalue to another.
// std::move 是将对象从一个左值移动到另一个左值的最常见方法。
// std::move 将表达式转换为右值。这允许我们将左值作为右值进行交互，并允许所有权从一个左值转移到另一个左值。// In the code below, we include some examples for identifying whether
// expressions in C++ are lvalues or rvalues, how to use std::move, and passing
// rvalues references into functions.
//在下面的代码中，我们提供了一些示例，用于识别 C++ 中的表达式是左值还是右值，如何使用std::move以及将右值引用传递到函数中。// Includes std::cout (printing) for demo purposes.
#include <iostream>
// Includes the utility header for std::move.
#include <utility>
// Includes the header for std::vector. We'll cover vectors more in
// containers.cpp, but what suffices to know for now is that vectors are
// essentially dynamic arrays, and the type std::vector<int> is an array of
// ints. Mainly, vectors take up a non-negligible amount of memory, and are here
// to show the performance benefits of using std::move.
#include <vector>// Function that takes in a rvalue reference as an argument.
// It seizes ownership of the vector passed in, appends 3 to
// the back of it, and prints the values in the vector.
// 这个函数传入一个右值引用,函数夺取传入的向量的所有权,并添加"3"在向量的最后,然后输出整个vector.
void move_add_three_and_print(std::vector<int> &&vec) {// 专利的move会产生"夺权"std::vector<int> vec1 = std::move(vec);vec1.push_back(3);for (const int &item : vec1) {std::cout << item << " ";}std::cout << "\n";
}// Function that takes in a rvalue reference as an argument.
// It appends 3 to the back of the vector passed in as an argument,
// and prints the values in the vector. Notably, it does not seize
// ownership of the vector. Therefore, the argument passed in would
// still be usable in the callee context.// 这个函数传入一个右值引用,函数中添加"3"在向量的最后，并打印向量中的值。
//值得注意的是,它不会夺取向量的所有权.因此,传入的参数在被调用方上下文中仍可用。
void add_three_and_print(std::vector<int> &&vec) {vec.push_back(3);for (const int &item : vec) {std::cout << item << " ";}std::cout << "\n";
}int main() {// Take this expression. Note that 'a' is a lvalue, since it's a variable that// refers to a specific space in memory (where 'a' is stored). 10 is a rvalue.int a = 10;//a是一个左值,因为它指向了一块特殊的内存空间。10是一个右值。// Let's see a basic example of moving data from one lvalue to another.// We define a vector of integers here.std::vector<int> int_array = {1, 2, 3, 4};// Now, we move the values of this array to another lvalue.std::vector<int> stealing_ints = std::move(int_array);// 一个左值move到另一个左值// Rvalue references are references that refer to the data itself, as opposed// to a lvalue. Calling std::move on a lvalue (such as stealing_ints) will// result in the expression being cast to a rvalue reference.// 右值引用是引用数据本身的引用，而不是左值。对左值（如 stealing_ints）调用std::move将导致表达式被强制转换为右值引用。std::vector<int> &&rvalue_stealing_ints = std::move(stealing_ints);// However, note that after this, it is still possible to access the data in// stealing_ints, since that is the lvalue that owns the data, not// rvalue_stealing_ints.//但是，请注意，在此之后，仍然可以在 stealing_ints 中访问数据，因为这是拥有数据的左值，而不是rvalue_stealing_ints。std::cout << "Printing from stealing_ints: " << stealing_ints[1] << std::endl;std::cout << "Printing from rvalue_stealing_ints: " << rvalue_stealing_ints[1] << std::endl;//这里下面这行直接报错退出，因为int_array对象的所有权已经没了。//std::cout << "Printing from int_array: " << int_array[1] << std::endl;// It is possible to pass in a rvalue reference into a function. However,// once the rvalue is moved from the lvalue in the caller context to a lvalue// in the callee context, it is effectively unusable to the caller.// Essentially, after move_add_three_and_print is called, we cannot use the// data in int_array2. It no longer belongs to the int_array2 lvalue.//可以将右值引用传递到函数中。但是，一旦右值从调用方上下文中的左值移动到被调用方上下文中的左值，//调用方实际上就无法使用它。从本质上讲，调用 move_add_three_and_print 后，//我们不能在 int_array2 中使用数据。它不再属于int_array2左值。std::vector<int> int_array2 = {1, 2, 3, 4};std::cout << "Calling move_add_three_and_print...\n";move_add_three_and_print(std::move(int_array2));// It would be unwise to try to do anything with int_array2 here. Uncomment// the code to try it out! (On my machine, this segfaults...) NOTE: THIS MIGHT// WORK FOR YOU. THIS DOES NOT MEAN THAT THIS IS WISE TO DO! // std::cout << int_array2[1] << std::endl;//如果在这里尝试使用int_array2,例如输出其中的一个值，那么会报错退出。因为在函数里面使用了move。// If we don't move the lvalue in the caller context to any lvalue in the// callee context, then effectively the function treats the rvalue reference// passed in as a reference, and the lvalue in this context still owns the// vector data.//如果在调用的函数里面没有使用move，那么函数会把右值引用转换为一个引用，情切左值仍然具有对象的使用权。std::vector<int> int_array3 = {1, 2, 3, 4};std::cout << "Calling add_three_and_print...\n";add_three_and_print(std::move(int_array3));// As seen here, we can print from this array.std::cout << "Printing from int_array3: " << int_array3[4] << std::endl;// 仅仅调用一次move方法std::vector<int> int_array4 = {1, 2, 3, 4};std::move(int_array4);std::cout << "Printing from int_array4: " << int_array4[1] << std::endl;// 调用move 给一个右值std::vector<int> int_array5 = {1, 2, 3, 4};std::vector<int> &&rvalue_stealing_intsstd5 = std::move(int_array5);std::cout << "Printing from rvalue_stealing_intsstd5: " << rvalue_stealing_intsstd5[1] << std::endl;std::cout << "Printing from int_array5: " << int_array5[1] << std::endl;// 调用move 给一个左值std::vector<int> int_array6 = {1, 2, 3, 4};std::vector<int> rvalue_stealing_intsstd6 = std::move(int_array6);std::cout << "Printing from rvalue_stealing_intsstd6: " << rvalue_stealing_intsstd6[1] << std::endl;// 下面这一行会报错退出std::cout << "Printing from int_array6: " << int_array6[1] << std::endl;return 0;
}