std::unique_ptr<T,Deleter>::operator= (3) - Linux Manuals

std::unique_ptr<T,Deleter>::operator=: std::unique_ptr<T,Deleter>::operator=

NAME

std::unique_ptr<T,Deleter>::operator= - std::unique_ptr<T,Deleter>::operator=

Synopsis

members of the primary template, unique_ptr<T>
unique_ptr& operator=( unique_ptr&& r ) noexcept; (1)
template< class U, class E > (1)
unique_ptr& operator=( unique_ptr<U,E>&& r ) noexcept;
unique_ptr& operator=( nullptr_t ) noexcept; (2)
members of the specialization for arrays, unique_ptr<T[]>
unique_ptr& operator=( unique_ptr&& r ) noexcept; (1)
template< class U, class E > (1) (since C++17)
unique_ptr& operator=( unique_ptr<U,E>&& r ) noexcept;
unique_ptr& operator=( nullptr_t ) noexcept; (2)

1) Transfers ownership from r to *this as if by calling reset(r.release()) followed by an assignment of get_deleter() from std::forward<E>(r.get_deleter()).
If Deleter is not a reference type, requires that it is nothrow-MoveAssignable.
If Deleter is a reference type, requires that std::remove_reference<Deleter>::type is nothrow-CopyAssignable.
The template version of this assignment operator only participates in overload resolution if U is not an array type and unique_ptr<U,E>::pointer is implicitly convertible to pointer
and std::is_assignable<Deleter&, E&&>::value is true
(since C++17).

The template version of this assignment operator in the specialization for arrays, std::unique_ptr<T[]> behaves the same as in the primary template, except that will only participate in overload resolution if all of the following is true:

* U is an array type
* pointer is the same type as element_type* (since C++17)
* unique_ptr<U,E>::pointer is the same type as unique_ptr<U,E>::element_type*
* unique_ptr<U,E>::element_type(*)[] is convertible to element_type(*)[]
* std::is_assignable<Deleter&, E&&>::value is true

2) Effectively the same as calling reset().
Note that unique_ptr's assignment operator only accepts rvalues, which are typically generated by std::move. (The unique_ptr class explicitly deletes its lvalue copy constructor and lvalue assignment operator.)

Parameters

r - smart pointer from which ownership will be transfered

Return value

*this

Example

// Run this code

  #include <iostream>
  #include <memory>

  struct Foo {
      int id;
      Foo(int id) : id(id) { std::cout << "Foo " << id << '\n'; }
      ~Foo() { std::cout << "~Foo " << id << '\n'; }
  };

  int main()
  {
      std::unique_ptr<Foo> p1( std::make_unique<Foo>(1) );

      {
          std::cout << "Creating new Foo...\n";
          std::unique_ptr<Foo> p2( std::make_unique<Foo>(2) );
          // p1 = p2; // Error ! can't copy unique_ptr
          p1 = std::move(p2);
          std::cout << "About to leave inner block...\n";

          // Foo instance will continue to live,
          // despite p2 going out of scope
      }

      std::cout << "About to leave program...\n";
  }

Output:

  Foo 1
  Creating new Foo...
  Foo 2
  ~Foo 1
  About to leave inner block...
  About to leave program...
  ~Foo 2