Soyez prudent lorsque vous comparez des nombres en C++

C++ est un langage de programmation largement utilisé, mais aussi celui dans lequel les erreurs de programmation sont les plus courantes. Beaucoup de ces erreurs sont dues à des erreurs logiques. En particulier, les erreurs commises lors des opérations de comparaison peuvent affecter la précision et la fiabilité de votre code.

Le langage C++ a une erreur de comparaison particulière que de nombreux nouveaux développeurs négligent. Cette erreur résulte d'une mauvaise compréhension du fonctionnement des opérateurs lors de l'exécution de plusieurs comparaisons. Découvrez comment éviter cette erreur courante et pourquoi elle se produit en premier lieu.

Comparaisons en C++

Le langage de programmation C++ offre de nombreuses fonctionnalités et outils différents, ainsi que des opérations de base telles que les opérateurs de comparaison. Les opérateurs de comparaison sont des opérations spéciales dans les langages de programmation que vous pouvez utiliser pour comparer des données entre elles. Les développeurs utilisent assez souvent ces opérateurs, en particulier lors de la création d'algorithmes.

Vous pouvez voir des opérateurs de comparaison dans de nombreux exemples différents de la vie quotidienne. Par exemple, lorsque vous magasinez à l'épicerie, vous utilisez ces opérateurs à l'esprit pour comparer les prix. Si le prix d'un produit est inférieur à l'autre, vous choisissez ce produit.

Vous pouvez voir les opérateurs de comparaison dans instructions if-else assez souvent. Les opérateurs de comparaison sont l'endroit où aller pour vérifier si une valeur est supérieure, inférieure ou égale à une autre valeur. Il y a un détail très petit mais important qu'il ne faut pas négliger. Les résultats des expressions de comparaison renvoient true ou false, qui sont des valeurs booléennes. Ces valeurs sont l'un des composants de base de la structure de contrôle en programmation.

Par exemple, dans le langage de programmation C++, le "==" L'opérateur vérifie si deux valeurs sont égales. Si les valeurs sont égales, le résultat renvoie vrai. Sinon, le résultat sera faux.

si (un == b)
{
retourvrai;
} 
autre
{
retourFAUX;
}

Un exemple de problème de comparaison

L'une des erreurs courantes des débutants en C++ est l'utilisation d'opérateurs de comparaison. Ces opérateurs permettent aux programmeurs de comparer deux valeurs et d'effectuer différentes opérations en fonction du résultat de cette comparaison. Cependant, l'utilisation incorrecte de ces opérateurs peut entraîner des erreurs inattendues.

Par exemple, bien que l'expression 3 < 15 < 10 soit mathématiquement incorrecte, C++ considère que son résultat est vrai. Vous pouvez le démontrer en écrivant le programme de test simple suivant.

Tout d'abord, créez un fichier nommé test.cpp. Ouvrez ce fichier à l'aide de votre éditeur de code préféré et ajoutez-y le code suivant.

#inclure
entier un = 15;
entierprincipal()
{
si (3 < un < 10)
 {
std::écoute << "fou" << std::fin;
 }
autre
 {
std::écoute << "huer" << std::fin;
 }
retour0;
}

Vous pouvez utiliser cette commande pour compiler et exécuter le code :

g++ test.cpp -o Test

Vous avez maintenant un programme appelé Test. Exécutez le programme et examinez sa sortie.

C++ considérait 3 < 15 < 10 comme vrai lors de l'exécution de ce programme. Pourquoi le résultat pourrait-il sortir de cette façon, même s'il s'agit d'une déclaration mathématiquement incorrecte ?

Causes du problème de comparaison en C++

Comme la plupart des langages de programmation, C++ lit le code de gauche à droite. Chaque opérateur de comparaison produit une valeur booléenne. Les valeurs booléennes ne signifient pas seulement vrai et faux; ils ont un équivalent mathématique.

Le principe de fonctionnement d'un l'ordinateur dépend des uns et des zéros. Pour un ordinateur, le résultat de quelque chose est soit vrai soit faux. Les programmes informatiques traitent généralement le nombre 1 comme vrai et le nombre 0 comme faux.

Examinez à nouveau le problème de comparaison et lisez l'énoncé de gauche à droite. vous verrez qu'il y a deux comparaisons différentes. La première comparaison est entre les nombres 3 et 15. Il s'agit d'une valeur vraie car 3 est inférieur à 15.

La deuxième comparaison est entre ce résultat et le nombre 10. Puisqu'il doit effectuer une comparaison numérique, C++ convertit silencieusement la vraie valeur booléenne en 1. 1 est inférieur à 10, donc le résultat global est vrai.

En conclusion, bien que cela semble être une erreur mathématique, cette affirmation est vraie pour C++ et les ordinateurs.

Comment résoudre les problèmes de comparaison en C++

C++, ainsi que la plupart des autres langages de programmation, utilise une syntaxe différente pour la comparaison logique que les mathématiques traditionnelles. L'expression mathématique 3 < a < 15 signifie « 3 est inférieur à a et a est inférieur à 15. Cependant, comme vous l'avez vu, C++ interprète cette expression différemment.

Pour représenter et en C++, utilisez l'opérateur &&. Vous pouvez ensuite enchaîner des expressions booléennes et créer une logique à l'aide d'opérateurs tels que && pour représenter ET, || pour représenter OU, et ! pour représenter NON. Des langues comme Java utilise les mêmes opérateurs logiques.

En utilisant l'opérateur logique correct, vous pouvez corriger le bogue de l'exemple précédent :

#inclure
entier un = 15;
entierprincipal()
{
si (3 < un && un < 10)
 {
std::écoute << "fou" << std::fin;
 }
autre
 {
std::écoute << "huer" << std::fin;
 }
retour0;
}

Maintenant, ce code va tester si la valeur a est supérieure à 3 et si la valeur a est inférieure à 10. Compilez et exécutez le programme et observez le résultat.

L'exemple précédent affichait "foo", mais le programme imprime maintenant "boo", comme prévu. La valeur booléenne du côté gauche de la comparaison (3 < a) est vraie. La valeur du côté droit (a < 10) est fausse. Depuis vrai et faux est toujours FAUX, l'expression globale prend la valeur false, de sorte que la condition échoue et que autre bloc s'exécute.

Essayez de changer le ET (&&) à un opérateur OR (||) et en observant le résultat différent.

L'importance des vérifications logiques en C++

Les comparaisons logiques en C++ impliquent l'utilisation de valeurs booléennes et d'opérateurs de comparaison. Assurez-vous d'utiliser les valeurs booléennes et les opérateurs de comparaison corrects pour contrôler le fonctionnement de vos programmes. Il peut être difficile de repérer les expressions mal formées car C++ adoptera souvent un comportement différent plutôt que d'échouer complètement.

Vous savez maintenant comment les compilateurs ignorent ce problème et traitent chaque comparaison comme un booléen lors de la lecture de gauche à droite. Faites attention à ce problème dans n'importe quelle langue que vous utilisez et apprenez à reconnaître ses effets afin de garder une longueur d'avance.