Namespaces
Variants

std::any:: operator=

From cppreference.net
C++
Utilities library
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, als ob durch std:: any ( rhs ) . swap ( * this ) .
2) Weist durch Verschieben des Zustands von rhs zu, als ob 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, als ob durch std:: any ( std:: forward < ValueType > ( rhs ) ) . swap ( * this ) . Diese Überladung nimmt nur dann 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.

Inhaltsverzeichnis

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)