网站建设评估报告,wordpress 移动,设计做网站,wordpress 全部文章左值右值
要理解move语义#xff0c;必须理解左值和右值的概念。左值的简化定义是左值是对象#xff0c;指向内存中某个位置。右值是左值之外的任何。
std::move()
move语义#xff0c;在C中是一个有用的方法#xff0c;它允许在对象之间高效和优化地转移数据所有权。m…左值右值
要理解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. Well cover vectors more in
// containers.cpp, but what suffices to know for now is that vectors are
// essentially dynamic arrays, and the type std::vectorint 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::vectorint vec) {// 专利的move会产生夺权std::vectorint 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::vectorint 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 its a variable that// refers to a specific space in memory (where a is stored). 10 is a rvalue.int a 10;//a是一个左值,因为它指向了一块特殊的内存空间。10是一个右值。// Lets see a basic example of moving data from one lvalue to another.// We define a vector of integers here.std::vectorint int_array {1, 2, 3, 4};// Now, we move the values of this array to another lvalue.std::vectorint 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::vectorint 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::vectorint 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 dont 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::vectorint 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::vectorint int_array4 {1, 2, 3, 4};std::move(int_array4);std::cout Printing from int_array4: int_array4[1] std::endl;// 调用move 给一个右值std::vectorint int_array5 {1, 2, 3, 4};std::vectorint 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::vectorint int_array6 {1, 2, 3, 4};std::vectorint 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;
}运行结果
