Namespaces
Variants

std::any:: operator=

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

Asigna contenido al valor contenido.

1) Asigna copiando el estado de rhs , como si fuera mediante std:: any ( rhs ) . swap ( * this ) .
2) Asigna moviendo el estado de rhs , como si fuera mediante std:: any ( std :: move ( rhs ) ) . swap ( * this ) . rhs queda en un estado válido pero no especificado después de la asignación.
3) Asigna el tipo y valor de rhs , como si fuera mediante std:: any ( std:: forward < ValueType > ( rhs ) ) . swap ( * this ) . Esta sobrecarga participa en la resolución de sobrecarga solo si std:: decay_t < ValueType > no es el mismo tipo que std::any y std:: is_copy_constructible_v < std:: decay_t < ValueType >> es true .

Contenidos

Parámetros de plantilla

ValueType - tipo de valor contenido
Requisitos de tipo
-
std:: decay_t < ValueType > debe cumplir con los requisitos de CopyConstructible .

Parámetros

rhs - objeto cuyo valor contenido se asignará

Valor de retorno

* this

Excepciones

1,3) Lanza std::bad_alloc o cualquier excepción lanzada por el constructor del tipo contenido. Si se lanza una excepción por cualquier razón, estas funciones no tienen efecto ( garantía fuerte de seguridad ante excepciones ).

Ejemplo

Ejecutar este código 
#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; // sobrecarga (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; // sobrecarga (3)
    a2 = "dog"s; // sobrecarga (3)
    a1 = std::move(a2); // sobrecarga (2)
    assert(a1.type() == typeid(std::string));
    assert(std::any_cast<std::string&>(a1) == "dog");
    // El estado de a2 es válido pero no especificado. De hecho,
    // es void en gcc/clang y std::string en msvc.
    std::cout << "a2.type(): " << std::quoted(a2.type().name()) << '\n';
    a1 = std::move(cat); // sobrecarga (3)
    assert(*std::any_cast<std::string>(&a1) == "cat");
    // El estado de cat es válido pero indeterminado:
    std::cout << "cat: " << std::quoted(cat) << '\n';
}

Salida posible: 

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

Véase también

construye un objeto any
(función miembro pública)