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 depuis C++23)
template < class U, class E >
unique_ptr & operator = ( unique_ptr < U, E > && r ) noexcept ;
(2) (constexpr depuis C++23)
unique_ptr & operator = ( std:: nullptr_t ) noexcept ;
(3) (constexpr depuis C++23)
unique_ptr & operator = ( const unique_ptr & ) = delete ;
(4)
1) Opérateur d'affectation par déplacement. Transfère la propriété de r vers * this comme en appelant reset ( r. release ( ) ) suivi de l'affectation de get_deleter() à partir de std:: forward < Deleter > ( r. get_deleter ( ) ) .
Cette surcharge participe à la résolution de surcharge seulement si std:: is_move_assignable < Deleter > :: value est true .
Si Deleter n'est pas un type référence, le comportement est indéfini si
Sinon ( Deleter est un type référence), le comportement est indéfini si
2) Opérateur d'affectation de conversion. Transfère la propriété de r vers * this comme en appelant reset ( r. release ( ) ) suivi de l'affectation de get_deleter() depuis std:: forward < E > ( r. get_deleter ( ) ) .
Cette surcharge participe à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :
  • std:: is_assignable < Deleter & , E && > :: value est true .
  • Pour le modèle primaire, toutes les conditions suivantes sont satisfaites :
    • U n'est pas un type tableau.
    • unique_ptr<U, E>::pointer est implicitement convertible en pointer , et.
  • Pour la spécialisation de tableau ( unique_ptr<T[]> ), toutes les conditions suivantes sont satisfaites :
    • U est un type tableau.
    • pointer est du même type que element_type* .
    • unique_ptr<U, E>::pointer est du même type que unique_ptr<U, E>::element_type* .
    • unique_ptr<U, E>::element_type(*)[] est convertible en element_type(*)[] .
Si E n'est pas un type référence, le comportement est indéfini si l'assignation de get_deleter() à partir d'une rvalue de type E est mal formée ou pourrait lever une exception.
Sinon ( E est un type référence), le comportement est indéfini si l'assignation de get_deleter() à partir d'un lvalue de type E est mal formée ou pourrait lever une exception.
3) Effectivement identique à l'appel de reset() .
4) L'opérateur de copie par affectation est explicitement supprimé.

Table des matières

Paramètres

r - pointeur intelligent dont la propriété sera transférée

Valeur de retour

* this

Notes

En tant que type à déplacement unique, unique_ptr , l'opérateur d'affectation n'accepte que des arguments rvalue (par exemple, le résultat de std::make_unique ou une variable unique_ptr sur laquelle std::move a été appliqué).

Exemple

Exécuter ce 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";
}

Sortie : 

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 2047 C++11 pour la surcharge (2) , get_deleter() était assigné à partir de
std:: forward < Deleter > ( r. get_deleter ( ) ) 		corrigé en
std:: forward < E > ( r. get_deleter ( ) )
LWG 2118 C++11 unique_ptr<T[]>::operator=
rejetait les conversions de qualification 		accepte
LWG 2228
( N4366 ) 		C++11 l'opérateur d'affectation de conversion
manquait la contrainte d'assignabilité 		contrainte ajoutée
LWG 2246 C++11 la cible d'affectation du
deleter converti de r n'était pas spécifiée 		spécifiée comme get_deleter()
LWG 2899 C++11 l'opérateur d'affectation de déplacement n'était pas contraint contraint