CKTIS / C++
std::is_convertible — vérifier une conversion implicite
std::is_convertible vérifie à la compilation si From peut être converti implicitement en To. std::is_convertible_v expose la même valeur bool sans ::value ; un résultat positif ne garantit ni la conservation de la valeur ni l’absence d’exceptions.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <type_traits>
std::is_convertible<From, To>::value
std::is_convertible_v<From, To>Dans l’en-tête <type_traits>, le trait std::is_convertible<From, To> expose une constante bool via ::value. Le modèle de variable std::is_convertible_v<From, To> est une forme abrégée de cette même valeur. Le type source vient en premier, suivi du type cible.
Le test modélise To test() { return std::declval<From>(); } : il vérifie que la conversion implicite est valide sans l’effectuer. L’accès est vérifié depuis un contexte sans lien avec l’un ou l’autre type ; seul le contexte immédiat de l’expression est pris en compte.
Un constructeur explicit ne suffit pas, même si std::is_constructible_v<To, From> peut valoir true. Les références et const comptent. Un résultat true ne garantit ni l’absence de perte ni l’absence d’exceptions.
Pour From comme pour To, les types autorisés sont les types complets, void avec ou sans qualificatifs cv, et les tableaux de taille inconnue. Ne passez pas une classe incomplète par valeur. Cette exigence ne suffit pas : si l’instanciation dépend directement ou indirectement d’un type d’objet incomplet et que compléter ce type pourrait changer le résultat, le comportement est indéfini. Par exemple, Derived* et Base* sont des types pointeurs complets, mais tester la conversion de Derived* vers Base* entraîne un comportement indéfini si compléter la définition de Derived pourrait changer le résultat.
L’exemple oppose un constructeur implicite à un constructeur explicit et vérifie la liaison de références.
Exemples
#include <iostream>
#include <type_traits>
struct Implicit {
Implicit(int) {}
};
struct Explicit {
explicit Explicit(int) {}
};
static_assert(std::is_convertible<int, Implicit>::value);
static_assert(!std::is_convertible_v<int, Explicit>);
static_assert(std::is_constructible_v<Explicit, int>);
static_assert(std::is_convertible_v<int&, const int&>);
static_assert(!std::is_convertible_v<const int&, int&>);
int main() {
std::cout << std::boolalpha
<< std::is_convertible<int, Implicit>::value << '\n'
<< std::is_convertible_v<int, Explicit> << '\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.