Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

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.

Sources