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 seit C++23)
template < class U, class E >
unique_ptr & operator = ( unique_ptr < U, E > && r ) noexcept ;
(2) (constexpr seit C++23)
unique_ptr & operator = ( std:: nullptr_t ) noexcept ;
(3) (constexpr seit C++23)
unique_ptr & operator = ( const unique_ptr & ) = delete ;
(4)
1) Move-Zuweisungsoperator. Überträgt den Besitz von r zu * this als ob durch Aufruf von reset ( r. release ( ) ) gefolgt von der Zuweisung von get_deleter() aus std:: forward < Deleter > ( r. get_deleter ( ) ) .
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn std:: is_move_assignable < Deleter > :: value true ist.
Wenn Deleter kein Referenztyp ist, ist das Verhalten undefiniert, falls
Andernfalls ( Deleter ist ein Referenztyp), ist das Verhalten undefiniert, wenn
2) Konvertierender Zuweisungsoperator. Überträgt Eigentumsrechte von r zu * this als ob durch Aufruf von reset ( r. release ( ) ) gefolgt von Zuweisung von get_deleter() aus std:: forward < E > ( r. get_deleter ( ) ) .
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:
  • std:: is_assignable < Deleter & , E && > :: value ist true .
  • Für das primäre Template sind alle folgenden Bedingungen erfüllt:
    • U ist kein Array-Typ.
    • unique_ptr<U, E>::pointer ist implizit konvertierbar zu pointer , und.
  • Für die Array-Spezialisierung ( unique_ptr<T[]> ) sind alle folgenden Bedingungen erfüllt:
    • U ist ein Array-Typ.
    • pointer ist vom gleichen Typ wie element_type* .
    • unique_ptr<U, E>::pointer ist vom gleichen Typ wie unique_ptr<U, E>::element_type* .
    • unique_ptr<U, E>::element_type(*)[] ist konvertierbar zu element_type(*)[] .
Wenn E kein Referenztyp ist, ist das Verhalten undefiniert, wenn die Zuweisung von get_deleter() von einem Rvalue des Typs E unzulässig ist oder eine Ausnahme auslösen würde.
Andernfalls ( E ist ein Referenztyp), ist das Verhalten undefiniert, wenn die Zuweisung von get_deleter() von einem lvalue vom Typ E ungültig wäre oder eine Exception auslösen würde.
3) Effektiv dasselbe wie der Aufruf von reset() .
4) Der Kopierzuweisungsoperator ist explizit gelöscht.

Inhaltsverzeichnis

Parameter

r - Smart Pointer, von dem das Eigentum übertragen wird

Rückgabewert

* this

Hinweise

Als ein Nur-Verschiebe-Typ akzeptiert der Zuweisungsoperator von unique_ptr nur Rvalue -Argumente (z.B. das Ergebnis von std::make_unique oder eine std::move -verschobene unique_ptr -Variable).

Beispiel

Diesen Code ausführen 
#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";
}

Ausgabe: 

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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 2047 C++11 für Überladung (2) , get_deleter() wurde zugewiesen von
std:: forward < Deleter > ( r. get_deleter ( ) ) 		korrigiert zu
std:: forward < E > ( r. get_deleter ( ) )
LWG 2118 C++11 unique_ptr<T[]>::operator=
lehnte Qualifikationskonvertierungen ab 		akzeptiert
LWG 2228
( N4366 ) 		C++11 der konvertierende Zuweisungsoperator
fehlte die Zuweisbarkeitsbedingung 		fügte die Bedingung hinzu
LWG 2246 C++11 das Zuweisungsziel des konvertierten
Deleter von r war nicht spezifiziert 		spezifiziert als get_deleter()
LWG 2899 C++11 der Move-Zuweisungsoperator war nicht eingeschränkt eingeschränkt