Namespaces
Variants

    std::any::operator=

    Von de.cppreference.net
     
    C++
     
    Dienstprogrammbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programm-Dienstprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Drei-Wege-Vergleich
    (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)
    Integer-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Tausch und Typ-Operationen
    (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)



     
    std::any
     
    any& operator=( const any& rhs );
    		(1) (seit C++17) 
    any& operator=( any&& rhs ) noexcept;
    		(2) (seit C++17) 
    template< typename ValueType >
any& operator=( ValueType&& rhs );
    		(3) (seit C++17)

    Weist dem enthaltenen Wert Inhalte zu.

    1) Weist durch Kopieren des Zustands von rhs zu, wie durch std::any(rhs).swap(*this).
    2) Weist durch Verschieben des Zustands von rhs zu, wie durch std::any(std::move(rhs)).swap(*this). rhs befindet sich nach der Zuweisung in einem gültigen, aber nicht spezifizierten Zustand.
    3) Weist den Typ und Wert von rhs zu, wie durch std::any(std::forward<ValueType>(rhs)).swap(*this). Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn std::decay_t<ValueType> nicht derselbe Typ wie std::any ist und std::is_copy_constructible_v<std::decay_t<ValueType>> true ist.

    Template-Parameter

    ValueType - enthaltene Wertart
    Typanforderungen
    -
    std:: decay_t < ValueType > muss die Anforderungen von CopyConstructible erfüllen.

    Parameter

    rhs - Objekt, dessen enthaltene Werte zugewiesen werden sollen

    Rückgabewert

    * this

    Ausnahmen

    1,3) Wirft std::bad_alloc oder eine beliebige Ausnahme, die vom Konstruktor des enthaltenen Typs ausgelöst wird. Wenn aus irgendeinem Grund eine Ausnahme ausgelöst wird, haben diese Funktionen keine Wirkung ( starke Ausnahmesicherheitsgarantie ).

    Beispiel

    Diesen Code ausführen 
    #include <any>
#include <cassert>
#include <iomanip>
#include <iostream>
#include <string>
#include <typeinfo>
int main()
{
    using namespace std::string_literals;
    std::string cat{"cat"};
    std::any a1{42};
    std::any a2{cat};
    assert(a1.type() == typeid(int));
    assert(a2.type() == typeid(std::string));
    a1 = a2; // Überladung (1)
    assert(a1.type() == typeid(std::string));
    assert(a2.type() == typeid(std::string));
    assert(std::any_cast<std::string&>(a1) == cat);
    assert(std::any_cast<std::string&>(a2) == cat);
    a1 = 96; // Überladung (3)
    a2 = "dog"s; // Überladung (3)
    a1 = std::move(a2); // Überladung (2)
    assert(a1.type() == typeid(std::string));
    assert(std::any_cast<std::string&>(a1) == "dog");
    // Der Zustand von a2 ist gültig aber unspezifiziert. Tatsächlich
    // ist es void in gcc/clang und std::string in msvc.
    std::cout << "a2.type(): " << std::quoted(a2.type().name()) << '\n';
    a1 = std::move(cat); // Überladung (3)
    assert(*std::any_cast<std::string>(&a1) == "cat");
    // Der Zustand von cat ist gültig aber unbestimmt:
    std::cout << "cat: " << std::quoted(cat) << '\n';
}

    Mögliche Ausgabe: 

    a2.type(): "void"
cat: ""

    Siehe auch

    		konstruiert ein any Objekt
    (öffentliche Elementfunktion)