Espacios de nombres
Variantes
Acciones

std::unique_ptr::operator=

De cppreference.com
< cpp‎ | memory‎ | unique ptr
 
C++
Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas
 
Biblioteca de servicios
 
Gestión de memoria dinámica
Punteros inteligentes
(C++11)
(C++11)
(C++11)
(hasta C++17)
(C++11)
(C++11)
(C++11)
(C++11)
(C++23)
(C++23)
Asignadores de memoria
(C++11)
(C++23)
(C++23)
(C++11)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20)
(C++11)
(C++17)
Recursos de memoria
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
Almacenamiento no inicializado
(hasta C++20)
(hasta C++20)
(hasta C++20)
Algoritmos de memoria no inicializada
Algoritmos restringidos de memoria no inicializada
Apoyo para recolección de basura
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
Misceláneos
(C++11)
(C++20)
(C++11)
(C++11)
(C++20)
 
std::unique_ptr
 
Miembros de la plantilla primaria, unique_ptr<T>
unique_ptr& operator=( unique_ptr&& r ) noexcept;
 (1) (constexpr since C++23)
template< class U, class E >
unique_ptr& operator=( unique_ptr<U,E>&& r ) noexcept;
 (2) (constexpr since C++23)
unique_ptr& operator=( std::nullptr_t ) noexcept;
 (3) (constexpr since C++23)
Miembros de la especialización para arrays, unique_ptr<T[]>
unique_ptr& operator=( unique_ptr&& r ) noexcept;
 (1) (constexpr since C++23)
template< class U, class E >
unique_ptr& operator=( unique_ptr<U,E>&& r ) noexcept;
 (2) (constexpr since C++23)
unique_ptr& operator=( std::nullptr_t ) noexcept;
 (3) (constexpr since C++23)
1) Operador de asignación de movimiento. Transfiere la posesión de r a *this como si se llamara a reset(r.release()) seguido por una asignación de get_deleter() de std::forward<Deleter>(r.get_deleter()).

Si Deleter no es un tipo referencia, requiere que sea nothrow-MoveAssignable.
Si Deleter es un tipo referencia, requiere que std::remove_reference<Deleter>::type sea nothrow-CopyAssignable.

El operador de asignación de movimiento solo participa en la resolución de sobrecarga si std::is_move_assignable<Deleter>::value es true.
2) Operador de asignación de conversión. Se comporta igual que (1), excepto que
  • Este operador de asignación de la plantilla primaria solo participa en la resolución de sobrecarga si U no es un tipo array y unique_ptr<U,E>::pointer es convertible implícitamente a pointer y std::is_assignable<Deleter&, E&&>::value es true.
  • Este operador de asignación en la especialización para arrays, std::unique_ptr<T[]> se comporta igual que en la plantilla primaria, excepto que solo participará en la resolución de sobrecarga si todo lo siguiente es verdadero:
  • U es un tipo array;
  • pointer es el mismo tipo que element_type*;
  • unique_ptr<U,E>::pointer es el mismo tipo que unique_ptr<U,E>::element_type*;
  • unique_ptr<U,E>::element_type(*)[] es convertible a element_type(*)[];
  • std::is_assignable<Deleter&, E&&>::value es true.
3) Efectivamente lo mismo que llamar a reset().

Ten en cuenta que el operador de asignación de unique_ptr solo acepta r-valores, que se generan típicamente por std::move (la clase unique_ptr elimina explícitamente su constructor de copia l-valor y su operador de asignación l-valor).

Contenido

[editar] Parámetros

r - Puntero inteligente desde el que se transferirá la posesión.

[editar] Valor de retorno

*this

[editar] Ejemplo

Ejecuta 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 << "Creando un nuevo objeto Foo...\n";
        std::unique_ptr<Foo> p2( std::make_unique<Foo>(2) );
        // p1 = p2; // ERROR: no se puede copiar un unique_ptr
        p1 = std::move(p2);
        std::cout << "A punto de salir del bloque interno...\n";
 
        // La instancia de Foo instance continuará viviendo, 
        // a pesar de que p2 saldrá de ámbito
    }
 
    std::cout << "A punto de salir del programa...\n";
}

Salida: 

Foo 1
Creando un nuevo objeto Foo...
Foo 2
~Foo 1
A punto de salir del bloque interno...
A punto de salir del programa...
~Foo 2

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID Aplicado a Comportamiento según lo publicado Comportamiento correcto
LWG 2118 C++11 unique_ptr<T[]>::operator= rechazaba las conversiones de calificación. Las acepta.
LWG 2228 C++11 El operador de asignación de conversión no estaba restringido. Se restringió.
LWG 2899 C++11 El operador de asignación de movimiento no estaba restringido. Se restringió.
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/memory/unique_ptr/operator%3D&oldid=41696»