Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::void_t — detectar tipos válidos

std::void_t, de <type_traits>, convierte cualquier paquete válido de argumentos de tipo en void. Combinado con SFINAE, permite detectar si un tipo anidado está disponible sin que todo el programa quede mal formado.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

template<class...> using void_t = void; // namespace std; header <type_traits>

std::void_t es una plantilla de alias declarada en <type_traits>. Para cualquier cantidad de argumentos de tipo válidos, denota void: tanto std::void_t<> como std::void_t<int, double> son el mismo tipo. No es una función ni un rasgo con valor booleano; no proporciona miembros propios ::type ni ::value.

Su utilidad se debe a la sustitución de argumentos de plantilla. En el ejemplo, typename T::value_type debe designar un tipo. Si es así, std::void_t<typename T::value_type> produce void, por lo que coincide la especialización parcial de has_value_type, que hereda de std::true_type. De lo contrario, la sustitución falla en el contexto inmediato, SFINAE descarta esa especialización y la plantilla principal proporciona std::false_type.

std::void_t acepta tipos, no expresiones arbitrarias. Para comprobar una expresión, se puede proporcionar su tipo mediante decltype(...). Esta técnica comprueba la validez sintáctica y de tipos, no los resultados calculados ni el comportamiento en tiempo de ejecución. No suprime todos los errores: un uso no válido fuera de un contexto SFINAE y los errores provocados por una instanciación incidental pueden seguir impidiendo la compilación.

Ejemplos

#include <iostream>
#include <type_traits>

template<class T, class = void>
struct has_value_type : std::false_type {};

template<class T>
struct has_value_type<T, std::void_t<typename T::value_type>>
    : std::true_type {};

struct Item {
    using value_type = int;
};

static_assert(std::is_same_v<std::void_t<>, void>);
static_assert(std::is_same_v<std::void_t<int, double>, void>);
static_assert(has_value_type<Item>::value);
static_assert(!has_value_type<int>::value);

int main() {
    std::cout << std::boolalpha
              << has_value_type<Item>::value << '\n'
              << has_value_type<int>::value << '\n';
}

Resultado

true
false

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes