Namespaces
Variants

std::any:: operator=

From cppreference.net
C++
Utilities library
std::any
any & operator = ( const any & rhs ) ;
(1) (depuis C++17)
any & operator = ( any && rhs ) noexcept ;
(2) (depuis C++17)
template < typename ValueType >
any & operator = ( ValueType && rhs ) ;
(3) (depuis C++17)

Assigne du contenu à la valeur contenue.

1) Affecte en copiant l'état de rhs , comme par std:: any ( rhs ) . swap ( * this ) .
2) Affecte en déplaçant l'état de rhs , comme par std:: any ( std :: move ( rhs ) ) . swap ( * this ) . rhs est laissé dans un état valide mais non spécifié après l'affectation.
3) Attribue le type et la valeur de rhs , comme par std:: any ( std:: forward < ValueType > ( rhs ) ) . swap ( * this ) . Cette surcharge participe à la résolution de surcharge seulement si std:: decay_t < ValueType > n'est pas le même type que std::any et si std:: is_copy_constructible_v < std:: decay_t < ValueType >> est true .

Table des matières

Paramètres du modèle

ValueType - type de valeur contenu
Exigences de type
-
std:: decay_t < ValueType > doit satisfaire aux exigences de CopyConstructible .

Paramètres

rhs - objet dont la valeur contenue doit être assignée

Valeur de retour

* this

Exceptions

1,3) Lance std::bad_alloc ou toute exception levée par le constructeur du type contenu. Si une exception est levée pour quelque raison que ce soit, ces fonctions n'ont aucun effet ( garantie de sécurité d'exception forte ).

Exemple

Exécuter ce code 
#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; // surcharge (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; // surcharge (3)
    a2 = "dog"s; // surcharge (3)
    a1 = std::move(a2); // surcharge (2)
    assert(a1.type() == typeid(std::string));
    assert(std::any_cast<std::string&>(a1) == "dog");
    // L'état de a2 est valide mais non spécifié. En réalité,
    // il est void dans gcc/clang et std::string dans msvc.
    std::cout << "a2.type(): " << std::quoted(a2.type().name()) << '\n';
    a1 = std::move(cat); // surcharge (3)
    assert(*std::any_cast<std::string>(&a1) == "cat");
    // L'état de cat est valide mais indéterminé :
    std::cout << "cat: " << std::quoted(cat) << '\n';
}

Sortie possible : 

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

Voir aussi

construit un objet any
(fonction membre publique)