How Can I Return a `std::unique_ptr` Without Using `std::move`?

Returning std::unique_ptr without std::move: How Is It Possible?

Despite the prohibition of copy construction in std::unique_ptr, it is possible to return a std::unique_ptr from a function without using std::move. This apparent contradiction is rooted in a specific exception allowed by the C language specification.

The Exception: Copy Elision

C allows copy elision under specific circumstances, as defined in 12.8 §34 and §35. One such case is when a non-volatile automatic object with the same cv-unqualified type as the function's return type is returned. In this scenario, the compiler is permitted to elide the copy construction process. This elision is applied to both copies and moves.

The Implementation of Copy Elision

When copy elision is employed in a return statement, the compiler first considers the object as an rvalue, even if it is an lvalue, for the purpose of overload resolution. Consequently, if a move constructor is available, it is selected, but no actual move operation is performed. This results in an empty move constructor call that acts as a placeholder and maintains the ownership semantics of the unique pointer.

Example

The following code demonstrates the phenomenon:

unique_ptr<int> foo()
{
  unique_ptr<int> p( new int(10) );

  return p; // Line 1, copy elision applied
}

int main()
{
  unique_ptr<int> p = foo();

  cout <p>In line 1, the returned unique_ptr<int> is treated as an rvalue during overload resolution. Since a move constructor is available, it is selected. However, the actual return value is the non-volatile automatic object p, not a moved value. The compiler elides the copy/move construction, allowing the return of a unique_ptr<int> without explicitly using std::move.</int></int></p>
<p><strong>Conclusion</strong></p>
<p>This exception to the copy constructor prohibition is specifically allowed by the C   language specification to facilitate efficient and concise return statements. However, it is important to note that copy elision is an optimization that the compiler may or may not perform. As such, it is generally recommended to explicitly use std::move in return statements to ensure the intended behavior.</p></int></int></int>

The above is the detailed content of How Can I Return a `std::unique_ptr` Without Using `std::move`?. For more information, please follow other related articles on the PHP Chinese website!