Les opérateurs dans C++
Après avoir introduit les variables et les constantes, nous pouvons commencer à les manipuler à l’aide d’opérateurs. Voici une liste exhaustive des différents opérateurs disponibles. Bien qu’il ne soit peut-être pas nécessaire de tous les maîtriser immédiatement, ils sont listés ici pour vous servir de référence à mesure que vous progressez.
Sommaire
Opérateur d’affectation (=)
L’opérateur d’affectation attribue une valeur à une variable.
x = 5;
Cette instruction attribue la valeur entière 5 à la variable x. L’opération d’affectation se déroule toujours de droite à gauche, et jamais l’inverse:
x = y;
Cette instruction assigne à la variable x la valeur actuellement contenue dans la variable y. La valeur de x, au moment où cette instruction est exécutée, est remplacée par celle de y, et l’ancienne valeur de x est perdue.
Il est important de noter que cette assignation de la valeur de y à x se produit uniquement au moment de l’exécution de l’affectation. Par conséquent, si y est modifié par la suite, cela n’affectera pas la nouvelle valeur de x.
Par exemple, analysons le code suivant, où l’évolution des valeurs stockées dans les variables est illustrée à l’aide de commentaires :
// opérateur d'assignation
#include <iostream>
using namespace std;
int main ()
{
int a, b; // un B : ?
a = 10; // a: 10, b : ?
b = 4; // a: 10, b: 4
a = b; // a: 4, b: 4
b = 7; // a: 4, b: 7
cout << "a:";
cout << a;
cout << "b:";
cout << b;
}
Ce programme affiche les valeurs finales de a et b (4 et 7, respectivement) sur l’écran. Vous remarquerez que la variable a n’a pas été impactée par la dernière modification de b, bien que nous ayons précédemment assigné a = b.
Les opérations d’affectation peuvent être considérées comme des expressions évaluables. Autrement dit, l’affectation elle-même génère une valeur, et pour les types de données de base, cette valeur correspond à celle attribuée au résultat de l’opération. Par exemple :
y = 2 + (x = 5);
Dans cette expression, y est affecté le résultat de l’ajout de 2 et la valeur d’une autre expression d’affectation (qui a elle-même la valeur 5). C’est à peu près équivalent à:
x = 5; y = 2 + x;
Avec le résultat final d’assigner 7 à y.
L’expression suivante est également valide en C ++:
x = y = z = 5;
Il attribue 5 aux trois variables: x, y et z; toujours de droite à gauche.
Opérateurs arithmétiques (+, -, *, /,%)
Les cinq opérations arithmétiques prises en charge par C ++ sont les suivantes:
Opérateur Description
+ addition
– soustraction
* multiplication
/ division
% modulo
Les opérations d’addition, de soustraction, de multiplication et de division correspondent directement à leurs équivalents mathématiques. L’opérateur modulo, représenté par le symbole pourcentage (%), renvoie le reste lors de la division de deux valeurs. Par exemple :
x = 11% 3;
donne la variable x contenant la valeur 2, puisqu’on divise 11 par 3, on obtient 3, avec un reste de 2.
Affectation composée (+ =, – =, * =, / =,% =, >> =, << =, & =, ^ =, | =)
Les opérateurs d’assignation composés modifient la valeur actuelle d’une variable en effectuant une opération dessus. Ils équivalent à assigner le résultat d’une opération au premier opérande:
expression équivalente à …
y + = x; y = y + x;
x – = 5; x = x – 5;
x / = y; x = x / y;
prix * = unités + 1; prix = prix * (unités + 1);
et la même chose pour tous les autres opérateurs d’affectation composée. Par exemple:
// opérateurs d'assignation composés
#include <iostream>
using namespace std;
int main ()
{
int a, b = 3;
a = b;
a + = 2; // équivalent à a = a + 2
cout << a;
}
Incrémenter et décrémenter (++, -)
Certaines expressions peuvent même être raccourcies: l’opérateur d’augmentation (++) et l’opérateur de diminution (-) augmentent ou diminuent de un la valeur stockée dans une variable. Ils sont équivalents à + = 1 et à – = 1, respectivement. Ainsi:
++ x; x + = 1; x = x + 1;
sont tous équivalents dans sa fonctionnalité; les trois augmentent de un la valeur de x.
Dans les premières versions des compilateurs C, les trois expressions précédentes pouvaient générer du code exécutable différent selon celle utilisée. Aujourd’hui, ce type d’optimisation est généralement pris en charge automatiquement par le compilateur, de sorte que les trois expressions produisent généralement le même code exécutable.
Une particularité de cet opérateur est qu’il peut être employé à la fois comme préfixe et comme suffixe. Cela signifie qu’il peut être placé avant le nom de la variable (++x) ou après (x++). Dans des expressions simples comme x++ ou ++x, les deux ont exactement la même signification. Cependant, dans des expressions où le résultat de l’opération d’incrémentation ou de décrémentation est évalué, ils peuvent avoir un impact différent : lorsqu’il est utilisé comme préfixe (++x), l’expression est évaluée à la valeur finale de x, après l’incrémentation. En revanche, lorsqu’il est utilisé comme suffixe (x++), l’incrémentation a bien lieu, mais l’expression est évaluée à la valeur que x avait avant cette augmentation. Notez bien cette différence :
Exemple 1 Exemple 2
x = 3; x = 3;
y = ++ x; y = x ++;
// x contient 4, y contient 4 // x contient 4, y contient 3
Dans l’exemple 1, la valeur attribuée à y est la valeur de x après avoir été augmentée. Dans l’exemple 2, c’est la valeur que x avait avant d’être augmentée.
Opérateurs relationnels et de comparaison (==,! =,>, <,> =, <=)
Deux expressions peuvent être comparées à l’aide d’opérateurs relationnels et d’égalité. Par exemple, pour savoir si deux valeurs sont égales ou si l’une est supérieure à l’autre.
Le résultat d’une telle opération est soit vrai, soit faux (c’est-à-dire une valeur booléenne).
Les opérateurs relationnels en C ++ sont:
opérateur description
== égal à
! = Pas égal à
< Inférieur à
> Plus grand que
<= Inférieur ou égal à
> = Supérieur ou égal à
Voici quelques exemples:
(7 == 5) // est évalué à faux (5> 4) // est évalué à true (3! = 2) // est évalué à true (6> = 6) // est évalué à true (5 <5) // est évalué à faux
Bien sûr, il n’est pas seulement possible de comparer des constantes numériques, mais bien n’importe quelle valeur, y compris, bien sûr, des variables. Supposons que a = 2, b = 3 et c = 6, alors:
a == 5) // est évalué à false, car a n'est pas égal à 5 (a * b> = c) // est évalué à vrai, puisque (2 * 3> = 6) est vrai (b + 4> a * c) // est considéré comme faux, puisque (3 + 4> 2 * 6) est faux ((b = 2) == a) // est évalué à true
Attention ! L’opérateur d’assignation (opérateur =, avec un seul signe égal) diffère de l’opérateur de comparaison d’égalité (opérateur ==, avec deux signes égaux). L’opérateur d’assignation (=) attribue la valeur à droite à la variable à gauche, tandis que l’opérateur de comparaison (==) vérifie si les valeurs des deux côtés de l’opérateur sont égales. Par conséquent, dans l’expression ((b = 2) == a), nous attribuons d’abord la valeur 2 à b, puis nous comparons cette valeur à a (qui stocke également 2), ce qui renvoie la valeur true.
Opérateurs logiques (!, &&, ||)
L’opérateur ! est l’opérateur C ++ pour l’opération booléenne NOT. Il n’a qu’un seul opérande, à sa droite, et l’inverse, produisant false si son opérande est vrai et vrai si son opérande est faux. En gros, il retourne la valeur booléenne opposée de l’évaluation de son opérande. Par exemple:
! (5 == 5) // est évalué à false car l'expression à sa droite (5 == 5) est vraie ! (6 <= 4) // est évalué à true car (6 <= 4) serait faux ! true // est évalué à false ! false // est évalué à true
Les opérateurs logiques && et || sont utilisés lors de l’évaluation de deux expressions pour obtenir un seul résultat relationnel. L’opérateur && correspond à l’opération logique booléenne AND, qui renvoie true si ses deux opérandes sont true et false sinon. Le panneau suivant montre le résultat de l’opérateur && évaluant l’expression a && b:
&& OPÉRATEUR (and)
a b a && b
vrai vrai vrai
vrai faux faux
faux vrai faux
faux faux faux
L’opérateur || correspond à l’opération logique booléenne OU, qui renvoie true si l’un de ses opérandes est vrai, donc faux uniquement lorsque les deux opérandes sont faux. Voici les résultats possibles de a || b:
|| OPÉRATEUR (or)
a b a || b
vrai vrai vrai
vrai faux vrai
faux vrai vrai
faux faux faux
Par exemple:
((5 == 5) && (3> 6)) // est évalué à false (true && false) ((5 == 5) || (3> 6)) // est évalué à vrai (vrai || faux)
En C++, les opérateurs logiques utilisent une évaluation dite « de court-circuit », où seule la partie nécessaire de l’expression est évaluée, de gauche à droite, pour déterminer le résultat global. Ainsi, dans l’exemple ((5 == 5) || (3 > 6)), C++ vérifie d’abord si 5 == 5 est vrai. Si c’est le cas, l’évaluation s’arrête immédiatement sans vérifier la condition 3 > 6. Ce comportement optimise l’exécution en évitant des évaluations inutiles pour les opérateurs logiques.
&& : Si l’expression de gauche est fausse, le résultat combiné est faux (l’expression de droite n’est jamais évaluée).
|| : Si l’expression de gauche est vraie, le résultat combiné est vrai (l’expression de droite n’est jamais évaluée).
Ceci est surtout important lorsque l’expression de droite a des effets secondaires, tels que la modification de valeurs:
if ((i <10) && (++ i <n)) {/*...*/} // notez que la condition incrémente i
Ici, l’expression conditionnelle combinée augmenterait de un, mais seulement si la condition à gauche de && est vraie, car sinon, la condition à droite (++ i <n) n’est jamais évaluée.
Opérateur ternaire conditionnel (?)
L’opérateur conditionnel évalue une expression en renvoyant une valeur si cette expression est évaluée à true et une valeur différente si l’expression est évaluée à false. Sa syntaxe est la suivante:
condition? result1: result2
Si condition est true, l’expression entière est évaluée à result1 et sinon à result2.
7 == 5? 4: 3 // est évalué à 3, puisque 7 n'est pas égal à 5. 7 == 5 + 2? 4: 3 // est évalué à 4, puisque 7 est égal à 5 + 2. 5> 3? a: b // est évalué à la valeur de a, puisque 5 est supérieur à 3. a> b? a: b // évalue celui qui est le plus grand, a ou b.
Par exemple:
// opérateur conditionnel
#include <iostream>
using namespace std;
int main ()
{
int a, b, c;
a = 2;
b = 7;
c = (a> b)? un B;
cout << c << '\ n';
}
Dans cet exemple, avec a égal à 2 et b égal à 7, l’expression (a > b) est fausse. En conséquence, la première valeur après le point d’interrogation est ignorée, et c’est la seconde valeur, située après le deux-points, qui est retenue. Ainsi, la valeur de b, soit 7, est celle qui est finalement utilisée.
