Namespaces
Variants

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

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::unique_ptr
unique_ptr & operator = ( unique_ptr && r ) noexcept ;
(1) (constexpr desde C++23)
template < class U, class E >
unique_ptr & operator = ( unique_ptr < U, E > && r ) noexcept ;
(2) (constexpr desde C++23)
unique_ptr & operator = ( std:: nullptr_t ) noexcept ;
(3) (constexpr desde C++23)
unique_ptr & operator = ( const unique_ptr & ) = delete ;
(4)
1) Operador de asignación de movimiento. Transfiere la propiedad de r a * this como si se llamara a reset ( r. release ( ) ) seguido de asignar get_deleter() desde std:: forward < Deleter > ( r. get_deleter ( ) ) .
Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_move_assignable < Deleter > :: value es true .
Si Deleter no es un tipo de referencia, el comportamiento es indefinido si
En caso contrario ( Deleter es un tipo referencia), el comportamiento es indefinido si
2) Operador de asignación de conversión. Transfiere la propiedad desde r hacia * this como si se llamara a reset ( r. release ( ) ) seguido de asignar get_deleter() desde std:: forward < E > ( r. get_deleter ( ) ) .
Esta sobrecarga participa en la resolución de sobrecarga solo si se cumplen todas las siguientes condiciones:
  • std:: is_assignable < Deleter & , E && > :: value es true .
  • Para la plantilla principal, se cumplen todas las siguientes condiciones:
    • U no es un tipo array.
    • unique_ptr<U, E>::pointer es convertible implícitamente a pointer , y.
  • Para la especialización de array ( unique_ptr<T[]> ), se cumplen todas las siguientes condiciones:
    • U es un tipo array.
    • pointer es del mismo tipo que element_type* .
    • unique_ptr<U, E>::pointer es del mismo tipo que unique_ptr<U, E>::element_type* .
    • unique_ptr<U, E>::element_type(*)[] es convertible a element_type(*)[] .
Si E no es un tipo de referencia, el comportamiento es indefinido si asignar get_deleter() desde un rvalue de tipo E está mal formado o lanzaría una excepción.
En caso contrario ( E es un tipo referencia), el comportamiento es indefinido si asignar get_deleter() desde un lvalue de tipo E está mal formado o lanzaría una excepción.
3) Esencialmente lo mismo que llamar a reset() .
4) El operador de asignación de copia está explícitamente eliminado.

Contenidos

Parámetros

r - puntero inteligente del cual se transferirá la propiedad

Valor de retorno

* this

Notas

Como un tipo de solo movimiento, unique_ptr , su operador de asignación solo acepta argumentos rvalues (por ejemplo, el resultado de std::make_unique o una variable unique_ptr a la que se le aplicó std::move ).

Ejemplo

Ejecutar este código 
#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";
}

Salida: 

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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR Se aplica a Comportamiento publicado Comportamiento correcto
LWG 2047 C++11 para la sobrecarga (2) , get_deleter() se asignaba desde
std:: forward < Deleter > ( r. get_deleter ( ) ) 		corregido a
std:: forward < E > ( r. get_deleter ( ) )
LWG 2118 C++11 unique_ptr<T[]>::operator=
rechazaba conversiones de calificación 		acepta
LWG 2228
( N4366 ) 		C++11 al operador de asignación de conversión
le faltaba la restricción de asignabilidad 		se añadió la restricción
LWG 2246 C++11 el destino de asignación del
deleter convertido de r no estaba especificado 		especificado como get_deleter()
LWG 2899 C++11 el operador de asignación de movimiento no estaba restringido restringido