Espacios de nombres
Variantes

    std::make_any

    De cppreference.com
     
    C++
    Apoyo de compiladores
    Implementaciones independientes y albergadas
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos denominados
    Macros de prueba de característica (C++20)
    Biblioteca de apoyo del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnósticos
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de servicios 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 apoyo de concurrencia (C++11)
    Biblioteca de apoyo de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de servicios
    Apoyo del lenguaje
    Apoyo de tipos (tipos básicos, RTTI)
    Macros de prueba de característica de la biblioteca (C++20)
    Servicios de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Apoyo de corrutinas (C++20)
    Apoyo de contratos (C++26)
    Comparación de 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)(C++20)

     
    std::any
     
    template< class T, class... Args >
std::any make_any( Args&&... args );
    		(1) (desde C++17) 
    template< class T, class U, class... Args >
std::any make_any( std::initializer_list<U> il, Args&&... args );
    		(2) (desde C++17)

    Construye un objeto any que contiene un objeto de tipo T, pasando los argumentos proporcionados al constructor de T.

    1) Equivalente a return std::any(std::in_place_type<T>, std::forward<Args>(args)...);.
    2) Equivalente a return std::any(std::in_place_type<T>, il, std::forward<Args>(args)...);.

    Ejemplo

    Ejecuta este código
    #include <any>
#include <complex>
#include <functional>
#include <iostream>
#include <string>

int main()
{
    auto a0 = std::make_any<std::string>("Hola, std::any!\n");
    auto a1 = std::make_any<std::complex<double>>(0.1, 2.3);

    std::cout << std::any_cast<std::string&>(a0);
    std::cout << std::any_cast<std::complex<double>&>(a1) << '\n';

    using lambda = std::function<void(void)>;

    // Poner una lambda dentro de std::any. Intento #1 (fallido).
    std::any a2 = [] { std::cout << "Lambda #1.\n"; };
    std::cout << "a2.type() = \"" << a2.type().name() << "\"\n";
    
    // any_cast convierte a <void(void)> pero el tipo actual no es
    // una std::function..., sino ~ main::{lambda()#1}, y es
    // única para cada lambda. Así que esto lanza...
    try {
        std::any_cast<lambda>(a2)();
    }
    catch (std::bad_any_cast const& ex) {
        std::cout << ex.what() << '\n';
    }

    // Poner una lambda dentro de std::any. Intento #2 (con éxito).
    auto a3 = std::make_any<lambda>([] { std::cout << "Lambda #2.\n"; });
    std::cout << "a3.type() = \"" << a3.type().name() << "\"\n";
    std::any_cast<lambda>(a3)();
}

    Posible salida: 

    Hola, std::any!
(0.1,2.3)
a2.type() = "Z4mainEUlvE_"
bad any_cast
a3.type() = "St8functionIFvvEE"
Lambda #2.

    Véase también

    		 Construye un objeto any.
    (función miembro pública) [editar]
    (C++17)
    		 Acceso de tipo seguro al objeto contenido.
    (plantilla de función) [editar]