Attention à la comparaison des nombres en C++

Le C++ est un langage de programmation très répandu, mais aussi un langage dans lequel les erreurs de programmation sont les plus fréquentes. Beaucoup de ces erreurs sont dues à des fautes de logique. 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++ comporte 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 comparaisons multiples. Découvrez comment éviter cette erreur courante et pourquoi elle se produit en premier lieu.

Les 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 très souvent ces opérateurs, notamment lors de la création d’algorithmes.

Les opérateurs de comparaison sont présents dans de nombreux exemples de la vie quotidienne. Par exemple, lorsque vous faites vos courses à l’épicerie, vous utilisez ces opérateurs pour comparer les prix. Si le prix d’un produit est inférieur à celui de l’autre, vous choisissez ce produit.

Les opérateurs de comparaison sont souvent présents dans les instructions if-else. Les opérateurs de comparaison permettent de vérifier si une valeur est supérieure, inférieure ou égale à une autre valeur. Il y a un petit détail important à ne 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++, l’expression « ==« vérifie si deux valeurs sont égales. Si les valeurs sont égales, le résultat est vrai. Dans le cas contraire, le résultat sera faux.

Exemple de problème de comparaison

L’une des erreurs les plus courantes commises par les débutants en C++ est l’utilisation des 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 provoquer des erreurs inattendues.

Par exemple, bien que l’expression 3 < 15 < 10 soit mathématiquement incorrecte, le C++ considère son résultat comme 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.

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

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

C++ considéré 3 < 15 < 10 comme étant vrai lors de l’exécution de ce programme. Pourquoi le résultat pourrait-il être ainsi, même s’il s’agit d’une affirmation mathématiquement incorrecte ?

Causes du problème de comparaison en C++

Comme la plupart des langages de programmation, le 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 ; elles ont un équivalent mathématique.

Le principe de fonctionnement d’un 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 considèrent généralement le chiffre 1 comme vrai et le chiffre 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 porte sur 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, le C++ convertit silencieusement la valeur booléenne true en 1. 1 est inférieur à 10, donc le résultat global est true.

En conclusion, bien qu’elle semble être une erreur mathématique, cette affirmation est vraie pour le C++ et les ordinateurs.

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

Le C++, comme la plupart des autres langages de programmation, utilise une syntaxe différente de celle des mathématiques traditionnelles pour les comparaisons logiques. 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, le C++ interprète cette expression différemment.

Pour représenter et en C++, on utilise la fonction && pour représenter et en C++. Vous pouvez ensuite enchaîner des expressions booléennes et construire une logique à l’aide d’opérateurs tels que && pour représenter AND, || pour représenter le OU, et ! pour représenter NOT. Des langages comme Java utilisent les mêmes opérateurs logiques.

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

Maintenant, ce code testera 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 affiche 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. Puisque est vrai et faux est toujours faux l’expression globale est évaluée à false, donc cette condition échoue et l’expression else s’exécute.

Essayez d’intervertir l’ET (&&) à un opérateur OR (||) et observez le résultat différent.

L’importance des contrôles logiques en C++

Les comparaisons logiques en C++ impliquent l’utilisation de valeurs booléennes et d’opérateurs de comparaison. Veillez à 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 le C++ adopte 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 lorsqu’ils lisent de gauche à droite. Soyez attentif à ce problème dans tous les langages que vous utilisez et apprenez à en reconnaître les effets afin de garder une longueur d’avance.

S’abonner à notre lettre d’information