CKTIS / C++
std::void_t — détecter les types valides
std::void_t, défini dans <type_traits>, associe tout paquet valide d’arguments de type à void. Combiné à SFINAE, il permet de détecter la disponibilité d’un type imbriqué sans rendre le programme entier mal formé.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
template<class...> using void_t = void; // namespace std; header <type_traits>std::void_t est un modèle d’alias déclaré dans <type_traits>. Pour tout nombre d’arguments de type valides, il désigne void : std::void_t<> et std::void_t<int, double> désignent le même type. Ce n’est ni une fonction ni un trait à valeur booléenne ; il ne fournit pas de membre propre ::type ou ::value.
Son intérêt vient de la substitution des arguments de modèle. Dans l’exemple, typename T::value_type doit désigner un type. Si c’est le cas, std::void_t<typename T::value_type> produit void, la spécialisation partielle de has_value_type correspond alors et hérite de std::true_type. Sinon, la substitution échoue dans le contexte immédiat, SFINAE écarte cette spécialisation et le modèle principal fournit std::false_type.
std::void_t accepte des types, pas des expressions arbitraires. Pour tester une expression, on peut fournir son type au moyen de decltype(...). Cette technique vérifie la validité syntaxique et typée, et non les résultats calculés ou le comportement à l’exécution. Elle ne supprime pas toutes les erreurs : une utilisation invalide hors d’un contexte SFINAE et les erreurs dues à une instanciation incidente peuvent toujours empêcher la compilation.
Exemples
#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';
}
Résultat
true false
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.