Namensräume
Varianten
Aktionen

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

Von cppreference.com
< cpp‎ | memory‎ | unique ptr
 
C++
 
Speicherverwaltungsbibliothek
(nur Exposition*)
Algorithmen für uninitialisierten Speicher
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)
(C++20)
Beschränkte uninitialisierte
Speicher-Algorithmen
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20) 
(C++20)
C-Bibliothek

Allocatoren
(C++11)
(C++23)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20) 
(C++11)
(C++17)
Speicherressourcen
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
Unterstützung für Garbage Collection
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
Uninitialisierter Speicher
(bis C++20*)
(bis C++20*)
(bis C++20*)
Explizites Lebenszeitmanagement
(C++23)(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 auf *this, als ob reset(r.release()) aufgerufen und danach get_deleter() von std::forward<Deleter>(r.get_deleter()) zugewiesen würde.
Diese Überladung nimmt an der Auflösung von Überladungen teil, nur wenn std::is_move_assignable<Deleter>::value true ist.
Wenn Deleter kein Referenztyp ist, ist das Verhalten undefiniert, wenn
Andernfalls (Deleter ist ein Referenztyp) ist das Verhalten undefiniert, wenn
2) Konvertierender Zuweisungsoperator. Überträgt den Besitz von r auf *this, als ob reset(r.release()) aufgerufen und danach get_deleter() von std::forward<E>(r.get_deleter()) zugewiesen würde.
Diese Überladung nimmt an der Überladungsauflösung teil, nur wenn alle folgenden Bedingungen erfüllt sind
  • std::is_assignable<Deleter&, E&&>::value ist true.
  • Für die primäre Vorlage sind alle folgenden Bedingungen erfüllt
    • U ist kein Array-Typ.
    • unique_ptr<U, E>::pointer ist implizit in pointer konvertierbar, 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 in element_type(*)[] konvertierbar.
Wenn E kein Referenztyp ist, ist das Verhalten undefiniert, wenn die Zuweisung von get_deleter() von einem Rvalue vom Typ E fehlerhaft ist oder eine Ausnahme auslöst.
Andernfalls (E ist ein Referenztyp) ist das Verhalten undefiniert, wenn die Zuweisung von get_deleter() von einem Lvalue vom Typ E fehlerhaft ist oder eine Ausnahme auslöst.
3) Im Wesentlichen dasselbe wie der Aufruf von reset().
4) Kopier-Zuweisungsoperator ist explizit gelöscht.

Inhalt

[bearbeiten] Parameter

r - Smart Pointer, von dem der Besitz übertragen werden soll

[bearbeiten] Rückgabewert

*this

[bearbeiten] Hinweise

Als ein nur-verschiebbarer 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).

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#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

[bearbeiten] 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=
zurückgewiesene Qualifizierungs-Konvertierungen		 akzeptiert
LWG 2228
(N4366)		 C++11 der konvertierende Zuweisungsoperator
hatte die Zuweisbarkeitsbedingung vergessen		 die Bedingung hinzugefügt
LWG 2246 C++11 das Zuweisungsziel des konvertierten
Deleter von r war nicht spezifiziert		 als get_deleter() spezifiziert
LWG 2899 C++11 der Move-Zuweisungsoperator war nicht eingeschränkt eingeschränkt
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/memory/unique_ptr/operator%3D&oldid=178191"