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

members of the primary template, unique_ptr<T>
unique_ptr& operator=( unique_ptr&& r ) noexcept;	(1)
template< class U, class E > unique_ptr& operator=( unique_ptr<U,E>&& r ) noexcept;	(1)
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 > unique_ptr& operator=( unique_ptr<U,E>&& r ) noexcept;	(1)	(since C++17)
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*
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

(since C++17)

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

Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Filesystem library (C++17)
Technical Specifications

Member functions
unique_ptr::unique_ptr
unique_ptr::~unique_ptr
unique_ptr::operator=
Modifiers
unique_ptr::release
unique_ptr::reset
unique_ptr::swap
Observers
unique_ptr::get
unique_ptr::get_deleter
unique_ptr::operator bool
unique_ptr::operator*unique_ptr::operator->
unique_ptr::operator[]
Non-member functions
make_uniquemake_unique_default_init (C++14)(C++20)
operator==operator!=operator<operator>operator<=operator>operator>=
operator<< (C++20)
std::swap
std::hash