Namespaces
Variants

    std::function<R(Args...)>::operator=

    Aus de.cppreference.net
     
    C++
     
    Dienstprogrammbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programmdienstprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinenunterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreifachvergleich
    (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++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Dienstprogramme
    Relationale Operatoren (veraltet in C++20)
    Ganzzahlvergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Tausch und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Funktionsobjekte
    Funktionsaufruf
    (C++17)(C++23)
    Identitätsfunktionsobjekt
    (C++20)
    Transparente Operatorwrapper
    (C++14)
    (C++14)
    (C++14)
    (C++14)  
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)
    (C++14)

    Alte Binder und Adaptoren
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)
    (bis C++17*)  
    (bis C++17*)
    (bis C++17*)(bis C++17*)(bis C++17*)(bis C++17*)
    (bis C++20*)
    (bis C++20*)
    (bis C++17*)(bis C++17*)
    (bis C++17*)(bis C++17*)

    (bis C++17*)
    (bis C++17*)(bis C++17*)(bis C++17*)(bis C++17*)
    (bis C++20*)
    (bis C++20*)
     
    std::function
     
    function& operator=( const function& other );
    		(1) (seit C++11) 
    function& operator=( function&& other );
    		(2) (seit C++11) 
    function& operator=( std::nullptr_t ) noexcept;
    		(3) (seit C++11) 
    template< class F >
function& operator=( F&& f );
    		(4) (seit C++11) 
    template< class F >
function& operator=( std::reference_wrapper<F> f ) noexcept;
    		(5) (seit C++11)

    Weist ein neues Zielstd::function zu.

    1) Weist eine Kopie des Ziels von other zu, als ob durch Ausführen von function(other).swap(*this);
    2) Verschiebt das Ziel von other nach *this. other befindet sich in einem gültigen Zustand mit einem nicht spezifizierten Wert.
    3) Entfernt das aktuelle Ziel. *this ist nach dem Aufruf leer.
    4) Setzt das Ziel von *this auf das aufrufbare f, als ob durch Ausführen von function(std::forward<F>(f)).swap(*this);. Dieser Operator nimmt nicht an der Überladungsauflösung teil, es sei denn, f ist Callable für Argumenttypen Args... und Rückgabetyp R.
    5) Setzt das Ziel von *this auf eine Kopie von f, als ob durch Ausführen von function(f).swap(*this);

    Parameter

    other - ein weiteres std::function Objekt, von dem das Ziel kopiert wird
    f - ein Aufrufbares zum Initialisieren des Ziels
    Typanforderungen
    -
    F muss die Anforderungen von Callable erfüllen.

    Rückgabewert

    * this

    Hinweise

    Selbst bevor die Allokatorunterstützung in C++17 aus std::function entfernt wurde, verwenden diese Zuweisungsoperatoren den Standardallokator anstelle des Allokators von * this oder des Allokators von other (siehe LWG issue 2386 ).

    Beispiel

    Diesen Code ausführen 
    #include <cassert>
#include <functional>
#include <utility>
int inc(int n) { return n + 1; }
int main()
{
    std::function<int(int)> f1;
    std::function<int(int)> f2(inc);
    assert(f1 == nullptr and f2 != nullptr);
    f1 = f2; // Überladung (1)
    assert(f1 != nullptr and f1(1) == 2);
    f1 = std::move(f2); // Überladung (2)
    assert(f1 != nullptr and f1(1) == 2);
    // f2 befindet sich in gültigem aber unspezifiziertem Zustand
    f1 = nullptr; // Überladung (3)
    assert(f1 == nullptr);
    f1 = inc; // Überladung (4)
    assert(f1 != nullptr and f1(1) == 2);
    f1 = [](int n) { return n + n; }; // Überladung (4)
    assert(f1 != nullptr and f1(2) == 4);
    std::reference_wrapper<int(int)> ref1 = std::ref(inc);
    f1 = ref1; // Überladung (5)
    assert(f1 != nullptr and f1(1) == 2);
}

    Fehlerberichte

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

    DR Angewendet auf Veröffentlichtes Verhalten Korrigiertes Verhalten
    LWG 2132 C++11 die Überladung ( 4 ) mit einem Callable Objekt könnte mehrdeutig sein eingeschränkt
    LWG 2401 C++11 Zuweisungsoperator ( 3 ) von std::nullptr_t nicht als noexcept gefordert gefordert

    Siehe auch

    		ersetzt oder zerstört das Zielobjekt
    (öffentliche Elementfunktion von std::move_only_function )
    (entfernt in C++17)
    		weist ein neues Zielobjekt zu
    (öffentliche Elementfunktion)