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

CKTIS / C++

explicit — contrôler les conversions implicites

Le spécificateur explicit restreint l’utilisation des constructeurs et des fonctions de conversion dans les conversions implicites, tout en permettant de construire volontairement des objets. Découvrez la différence entre initialisation directe et par copie, le rôle particulier de operator bool et explicit(condition).

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

explicit ClassName(parameters);
explicit operator TargetType() const;
explicit(condition) ClassName(parameters);
explicit(condition) operator TargetType() const;

explicit aide à restreindre les conversions définies par l’utilisateur qui pourraient être involontaires. Il peut qualifier un constructeur ou une fonction de conversion dans une définition de classe ; ce n’est pas un spécificateur pour les fonctions ordinaires. Il peut aussi apparaître sur les guides de déduction de paramètres de classe. explicit sans condition signifie explicit(true).

Pour un constructeur explicit Count(int), Count a(3); et Count b{3}; sont tous deux des initialisations directes valides. Count c = 3; est invalide, car l’initialisation par copie n’utilise pas ce constructeur pour la conversion. Count d = {3}; est également invalide si l’initialisation par liste avec copie sélectionne un constructeur explicit. De même, une fonction qui prend un Count ne peut pas accepter directement 3, mais peut recevoir Count{3}. Ce spécificateur ne se limite pas aux constructeurs à un seul paramètre.

Une fonction de conversion explicit operator bool() const interdit bool e = a;, mais autorise static_cast<bool>(a) et l’initialisation directe bool e(a);. Les conditions booléennes constituent une exception importante : if (a) peut utiliser cet opérateur, car la conversion contextuelle vers bool vérifie si l’initialisation directe est possible. Cela n’autorise pas les conversions implicites en général.

En C++23, explicit(condition) obéit à des règles plus strictes qu’une condition if ordinaire : le résultat de la conversion contextuelle en bool doit être une expression constante, et la séquence ne peut contenir que des conversions autorisées, à l’exclusion des conversions réductrices. Par exemple, 2 est une expression constante et peut servir de condition dans if (2), mais explicit(2) est mal formé, car la conversion de 2 en bool est réductrice. La valeur true active explicit ; false laisse la déclaration non explicite. Ce n’est pas un commutateur à l’exécution. Cette forme est utile dans les modèles lorsque la convertibilité implicite dépend du type. L’exemple utilise le mode C++23. Les sources présentent un projet de norme en évolution, et non une publication C++23 figée.

Exemples

#include <iostream>
#include <type_traits>

struct Count {
    int value;
    explicit Count(int n) : value(n) {}
    explicit operator bool() const { return value != 0; }
};

static_assert(std::is_constructible_v<Count, int>);
static_assert(!std::is_convertible_v<int, Count>);
static_assert(!std::is_convertible_v<Count, bool>);

int main() {
    Count a(3);
    Count b{0};
    // Count c = 3;
    // Count d = {3};
    // bool e = a;
    if (a) {
        std::cout << a.value << '\n';
    }
    std::cout << std::boolalpha << static_cast<bool>(b) << '\n';
}

Résultat

3
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