What Does the Double Ampersand (T&&) in C 11 Really Mean?

Demystifying the Double Ampersand (T&&) in C 11

At the forefront of C 11's novel features lies the double ampersand (&&), often seen in variable declarations such as T&& var. But what exactly does this enigmatic syntax represent?

Introduction to Rvalue References

The double ampersand declares an rvalue reference, as defined in the standards proposal document. Unlike traditional references (now referred to as lvalue references in C 11), which can only bind to lvalues (named objects), rvalue references can bind to rvalues, including temporaries.

Key Differences from Lvalue References

The primary distinction between rvalue references and lvalue references is that rvalue references can bind to rvalues without requiring the const keyword. This enables the following legal syntax:

T&& r = T();

Benefits of Rvalue References

Rvalue references provide several significant advantages:

1. Move Semantics:

Rvalue references facilitate the implementation of move constructors and move assignment operators, which enable efficient relocation of resources without having to copy data needlessly.

2. Perfect Forwarding:

With rvalue references, template functions can correctly forward arguments, preserving their lvalue or rvalue status, leading to more versatile and maintainable code.

Properties of Rvalue References:

• Overload resolution favors lvalue references for lvalues and rvalue references for rvalues.
• Rvalue references can bind to temporaries resulting from implicit conversions.
• Named rvalue references are lvalues, while unnamed rvalue references are rvalues.

Example: Move Semantics

Consider the following copy constructor:

foo(foo const& other) {
  this->length = other.length;
  this->ptr = new int[other.length];
  copy(other.ptr, other.ptr + other.length, this->ptr);
}

This copy constructor could be improved by taking an rvalue reference in a move constructor, which modifies its argument:

foo(foo&& other) {
  this->length = other.length;
  this->ptr = other.ptr;
  other.length = 0;
  other.ptr = nullptr;
}

This move constructor effectively "moves" the temporary into the newly constructed object, avoiding unnecessary copying.

Conclusion:

Rvalue references, denoted by the double ampersand (&&), extend the capabilities of C by introducing rvalue-specific syntax. They enable move semantics, perfect forwarding, and improved efficiency in handling temporary objects, solidifying their importance in modern C programming.

The above is the detailed content of What Does the Double Ampersand (T&&) in C 11 Really Mean?. For more information, please follow other related articles on the PHP Chinese website!