Shulou(Shulou.com)06/01 Report--

This article mainly explains "what are the new features of C++11". The explanation in this article is simple and clear, easy to learn and understand. Please follow the ideas of Xiaobian and go deep into it slowly to study and learn "what are the new features of C++11" together.

rvalue references

Although you cannot bind an rvalue directly to an lvalue, you can explicitly convert an lvalue to the corresponding rvalue reference type. We can get references bound to lvalues by calling a new standard library function called move. header file

int &&rr3 = std::move(rr1); //ok

We can destroy a post-source object or assign it a new value, but we cannot use the value of a post-source object.

L-values have persistent state, while r-values are either literal constants or temporary objects created during expression evaluation.

An rvalue reference points to an object to be destroyed. Thus, state can be "stolen" from an object bound to an rvalue reference, i.e., code referenced with an rvalue is free to take over the resources of the referenced object.

An rvalue reference is a reference that must be bound to an rvalue. Get rvalue references by && instead of &. An rvalue reference has one important property-it can only bind to an object that is to be destroyed. Thus we are free to "move" resources referenced by one rvalue to another object.

In general, an l-valued expression represents the identity of an object, and an r-valued expression represents the value of the object.

Like any reference, an rvalue reference is nothing more than the name of an object. A regular reference (an l-value reference) cannot be bound to an expression that requires conversion, literal constants, or an expression that returns an r-value. An rvalue reference is the opposite: you can bind an rvalue reference to such an expression, but you cannot bind an rvalue reference directly to an lvalue.

int i = 42;int &r = i; //correct, r references i, lvalue references int &&r = i; //Error, cannot bind an rvalue reference to an lvalue int &r2 = i * 42; //error, i * 42 is an rvalue const int &r3 = i * 42; //Correct, you can bind a reference to const to an rvalue int &r2 = i * 42; //correct, bind rr2 to multiplication result

1. Functions that return an lvalue reference, along with assignment, subscript, dereference, and preincrement and decrement operators, are examples of expressions that return an lvalue. 2. Functions that return non-reference types, along with arithmetic, relational, bitwise, and post-increment and decrement operators, produce rvalues. We cannot bind an l-value reference to such an expression, but we can bind an l-value reference to const and an r-value reference to such an expression.

Left-value persistent, r-value transient

Variables are l-valued, and you cannot bind an r-valued reference directly to a variable, even if the variable is of r-valued reference type.

int &&rr1 = 42; //correct, literal constant is rvalue int &rr2 = rr1; //error, expression rr1 is an lvalue

The move function of the standard library

Move Constructors and Move Assignment Operators

Because the mobile operation "steals" resources, it usually does not allocate any resources. Therefore, move operations usually do not throw any exceptions.

When writing a move operation that does not throw an exception, we should inform the standard library about it. Unless the standard library knows it won't throw an exception, it does some extra work to handle the possibility that an exception might be thrown.

One way to inform the standard library is to indicate the constructor as noexcept. This keyword was introduced by the new standard.

Move constructors and move assignment operators that do not throw exceptions must be marked noexcept.

Like the copy constructor, the first argument to the move constructor is a reference to the class type. Unlike the copy constructor, this reference parameter is an rvalue reference in the move constructor. As with copy constructors, any additional arguments must have default arguments.

In addition to completing the resource move, the move constructor must ensure that the moved source object is in a state where destroying it is harmless. In particular, once the resource is moved, the source object must no longer point to the moved resource. Ownership of these resources is already vested in the newly created object.

Move operations, standard library containers, and exceptions

Post-source object must be destructible

Moving data from an object does not destroy the object, but sometimes the source object is destroyed after the move operation is complete. When we write a move operation, we must ensure that the source object is moved back into a destructible state. That is, by setting the pointer member of the source object to nullptr.

After the move operation, the moved source object must remain in a valid, destructible state, but the user cannot make any assumptions about its value.

synthetic move operation

If a class defines its own copy constructor, copy assignment operator, or destructor, the compiler does not synthesize move constructors and move assignment operators for it.

The compiler synthesizes move constructors and move assignment operators for a class only if it does not define any copy control members of its own version and every nonstatic data of the class can be moved.

A class that defines a move constructor or move assignment operator must also define its own copy operation. Otherwise, these members are defined as deleted by default.

Thank you for reading, the above is "C++11 new features what" content, after the study of this article, I believe that we have a deeper understanding of C++11 new features what this problem, the specific use of the situation also needs to be verified by practice. Here is, Xiaobian will push more articles related to knowledge points for everyone, welcome to pay attention!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.