Comment puis-je empêcher les conversions de types implicites dans les fonctions C non constructives ?

Éviter les conversions implicites dans les fonctions non constructives

Dans le code fourni, la fonction function est déclarée pour accepter un paramètre entier. Cependant, il accepte également par inadvertance des caractères, des booléens et des longs en raison d'un casting implicite. Pour éviter ce comportement indésirable, nous recherchons des méthodes pour appliquer une correspondance de type stricte et interdire les conversions implicites.

Utiliser des modèles de fonction pour appliquer l'incompatibilité de type

Une approche pour éviter les conversions implicites consiste à définir un modèle de fonction qui correspond à tous les types sauf le type souhaité. Par exemple, nous pouvons créer un modèle pour d'autres types et le marquer comme supprimé, interdisant ainsi sa compilation :

void function(int); // this will be selected for int only

template<class T>
void function(T) = delete; // C++11

De cette façon, la fonction non-modèle avec une correspondance directe, dans ce cas la fonction void (int), sera toujours sélectionné pour les entiers. Toute tentative d'appel de la fonction avec d'autres types déclenchera une erreur en raison du modèle supprimé.

Approche pré-C 11 utilisant une surcharge de suppression

Avant C 11, une méthode différente était nécessaire pour réaliser des appels de fonction stricts sans conversions implicites. Cela impliquait de créer une classe DeleteOverload et de l'utiliser pour désactiver la sélection de surcharge pour les types non souhaités :

// because this ugly code will give you compilation error for all other types
class DeleteOverload
{
private:
    DeleteOverload(void*);
};

template<class T>
void function(T a, DeleteOverload = 0);

void function(int a)
{}

C 23 Assertion statique pour l'application des contraintes de type

C 23 introduit une classe plus conviviale approche utilisant static_assert(false, msg). Cela permet d'afficher des messages d'erreur plus clairs en cas d'incompatibilité de type :

void function(int) {} // this will be selected for int only

template<class T>
void function(T) {
    // since C++23
    static_assert(false, "function shall be called for int only");
}
int main() {
    function(1);
    // function(1l);
    // ^^^^^^^^^^^^ produces error:
    // error: static assertion failed: function shall be called for int only
}

Conclusion

En employant ces techniques, nous pouvons éviter les conversions implicites dans les fonctions non constructives, garantissant une vérification de type plus stricte et éliminant les erreurs potentielles. causé par des incompatibilités de types involontaires.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!