std::any_cast

 

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) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::any

Funciones miembro

any::any

any::~any

any::operator=

Modificadores

any::emplace

any::reset

any::swap

Observadores

any::has_value

any::type

Funciones no miembro

swap(std::any)

any_cast

make_any

 

template<class T> T any_cast(const any& operand);	(1)	(desde C++17)
template<class T> T any_cast(any& operand);	(2)	(desde C++17)
template<class T> T any_cast(any&& operand);	(3)	(desde C++17)
template<class T> const T* any_cast(const any* operand) noexcept;	(4)	(desde C++17)
template<class T> T* any_cast(any* operand) noexcept;	(5)	(desde C++17)

Realize acceso de tipo seguro al objeto contenido.

Dejemos que U sea std::remove_cv_t<std::remove_reference_t<T>>.

1) El programa está mal formado si std::is_constructible_v<T, const U&> es false.

2) El programa está mal formado si std::is_constructible_v<T, U&> es false.

3) El programa está mal formado si std::is_constructible_v<T, U> es false.

Parámetros

operand

-

Objeto any destino.

Valor de retorno

1-2) Devuelve static_cast<T>(*std::any_cast<U>(&operand)).

3) Devuelve static_cast<T>(std::move(*std::any_cast<U>(&operand))).

4-5) Si operand no es un puntero nulo, y el typeid de la T solicitada coincide con el contenido de operand, un puntero al valor contenido por el operando operand; de lo contrario, un puntero nulo.

Excepciones

1-3) Lanza std::bad_any_cast si el typeid de la T solicitada no coincide con el contenido de operand.

Ejemplo

Ejecuta este código

#include <string>
#include <iostream>
#include <any>
#include <utility>
 
int main()
{
    // ejemplo simple
 
    auto a = std::any(12);
 
    std::cout << std::any_cast<int>(a) << '\n'; 
 
    try {
        std::cout << std::any_cast<std::string>(a) << '\n';
    }
    catch(const std::bad_any_cast& e) {
        std::cout << e.what() << '\n';
    }
 
    // ejemplo con puntero
    
    if (int* i = std::any_cast<int>(&a)) {
       std::cout << "a es int: " << *i << '\n';
    } else if (std::string* s = std::any_cast<std::string>(&a)) {
       std::cout << "a es std::string: " << *s << '\n';
    } else {
       std::cout << "a es otro tipo o no está establecido\n";
    }

    // ejemplo avanzado
 
    a = std::string("hola");
 
    auto& ra = std::any_cast<std::string&>(a); //< referencia
    ra[0] = 'b';
 
    std::cout << "a: "
        << std::any_cast<const std::string&>(a) << '\n'; //< referencia const
 
    auto b = std::any_cast<std::string&&>(std::move(a)); //< referencia rvalue
 
    // Nota: 'b' es un std::string construído por movimiento,
    // 'a' se deja en un estado válido pero sin especificar
 
    std::cout << "a: " << *std::any_cast<std::string>(&a) //< puntero
        << "b: " << b << '\n';
}

Posible salida:

12
bad any_cast
a es int: 12
a: bola
a: b: bola