Namespaces
Variants

    std::any::any

    de es.cppreference.net
     
    C++
    Soporte de compiladores
    Libre y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte de lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte de lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de biblioteca (C++20)
    Utilidades de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación a tres vías
    (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)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
     
    std::any
     
    constexpr any() noexcept;
    		(1) (desde C++17) 
    any( const any& other );
    		(2) (desde C++17) 
    any( any&& other ) noexcept;
    		(3) (desde C++17) 
    template< class ValueType >
any( ValueType&& value );
    		(4) (desde C++17) 
    template< class ValueType, class... Args >
explicit any( std::in_place_type_t<ValueType>, Args&&... args );
    		(5) (desde C++17) 
    template< class ValueType, class U, class... Args >
explicit any( std::in_place_type_t<ValueType>, std::initializer_list<U> il,
              Args&&... args );
    		(6) (desde C++17)

    Construye un nuevo objeto any.

    1) Construye un objeto vacío.
    2,3) Copia (2) o mueve (3) el contenido de other a una nueva instancia, de modo que cualquier contenido sea equivalente tanto en tipo como en valor al de other antes de la llamada al constructor, o vacío si other está vacío. Formalmente,
    2) Si other está vacío, el objeto construido está vacío. De lo contrario, equivalente a any(std::in_place_type<T>, std::any_cast<const T&>(other)), donde T es el tipo del objeto contenido en other.
    3) Si other está vacío, el objeto construido está vacío. De lo contrario, el objeto construido contiene ya sea el objeto contenido en other, o un objeto del mismo tipo construido a partir del objeto contenido en other, considerando ese objeto como un valor-r.
    4) Construye un objeto cuyo contenido inicial es un objeto de tipo std::decay_t<ValueType>, inicializado directo desde std::forward<ValueType>(value).
    • Esta sobrecarga participa en la resolución de sobrecarga solo si std::decay_t<ValueType> no es del mismo tipo que any ni una especialización de std::in_place_type_t, y std::is_copy_constructible_v<std::decay_t<ValueType>> es true.
    5) Construye un objeto cuyo contenido inicial es un objeto de tipo std::decay_t<ValueType>, inicializado directo sin lista desde std::forward<Args>(args)....
    • Esta sobrecarga participa en la resolución de sobrecarga solo si std::is_constructible_v<std::decay_t<ValueType>, Args...> y std::is_copy_constructible_v<std::decay_t<ValueType>> son ambos true.
    6) Construye un objeto cuyo contenido inicial es un objeto de tipo std::decay_t<ValueType>, inicializado directo sin lista desde il, std::forward<Args>(args)....
    • Esta sobrecarga participa en la resolución de sobrecarga solo si std::is_constructible_v<std::decay_t<ValueType>, std::initializer_list<U>&, Args...> y std::is_copy_constructible_v<std::decay_t<ValueType>> son ambos true.

    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

    otro - otro any objeto desde el cual copiar o mover
    valor - valor con el cual inicializar el valor contenido
    il, args - argumentos que se pasarán al constructor del objeto contenido

    Excepciones

    2,4-6) Lanza cualquier excepción lanzada por el constructor del tipo contenido.

    Notas

    Debido a que el constructor por defecto es constexpr , los std::any estáticos se inicializan como parte de la inicialización no-local estática , antes de que comience cualquier inicialización no-local dinámica. Esto hace que sea seguro usar un objeto de tipo std::any en el constructor de cualquier objeto estático.

    Ejemplo

    Ejecutar este código 
    #include <boost/core/demangle.hpp>
#include <any>
#include <initializer_list>
#include <iostream>
#include <memory>
#include <set>
#include <string>
#include <utility>
struct A
{
    int age;
    std::string name;
    double salary;
#if __cpp_aggregate_paren_init < 201902L
    // Requerido antes de C++20 para construcción in situ
    A(int age, std::string name, double salary)
        : age(age), name(std::move(name)), salary(salary) {}
#endif
};
// Usando abi demangle para imprimir nombre de tipo legible de instancia any
void printType(const std::any& a)
{
    std::cout << boost::core::demangle(a.type().name()) << '\n';
}
int main()
{
    // Constructor #4: std::any conteniendo int
    std::any a1{7};
    // Constructor #5: std::any conteniendo A, construido in situ
    std::any a2(std::in_place_type<A>, 30, "Ada", 1000.25);
    // Constructor #6: std::any conteniendo un set de A con comparación personalizada
    auto lambda = [](auto&& l, auto&& r){ return l.age < r.age; };
    std::any a3(
        std::in_place_type<std::set<A, decltype(lambda)>>,
        {
            A{39, std::string{"Ada"}, 100.25},
            A{20, std::string{"Bob"}, 75.5}
        },
        lambda);
    printType(a1);
    printType(a2);
    printType(a3);
}

    Salida posible: 

    int
A
std::set<A, main::{lambda(auto:1&&, auto:2&&)#1}, std::allocator<A> >

    Véase también

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