Les opérateurs dans C++
Une fois les variables et les constantes introduites, nous pouvons commencer à les utiliser en utilisant des opérateurs. Ce qui suit est une liste complète des opérateurs. À ce stade, il n’est probablement pas nécessaire de les connaître toutes, mais elles sont toutes répertoriées ici pour servir également de référence.
Contenu de l'article
- OpĂ©rateur d’affectation (=)
- Opérateurs arithmétiques (+, -, *, /,%)
- Affectation composĂ©e (+ =, – =, * =, / =,% =, >> =, << =, & =, ^ =, | =)
- Incrémenter et décrémenter (++, -)
- Opérateurs relationnels et de comparaison (==,! =,>, <,> =, <=)
- Opérateurs logiques (!, &&, ||)
- Opérateur ternaire conditionnel (?)
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 affecte à la variable x la valeur contenue dans la variable y. La valeur de x au moment où cette instruction est exécutée est perdue et remplacée par la valeur de y.
ConsidĂ©rez Ă©galement que nous n’affectons la valeur de y Ă x que lors de l’affectation. Par consĂ©quent, si y change ultĂ©rieurement, cela n’affectera pas la nouvelle valeur prise par x.
Par exemple, examinons le code suivant – j’ai inclus l’Ă©volution du contenu stockĂ© dans les variables sous forme 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 imprime Ă l’Ă©cran les valeurs finales de a et b (4 et 7, respectivement). Remarquez comment a n’a pas Ă©tĂ© affectĂ© par la modification finale de b, mĂŞme si nous avons dĂ©jĂ dĂ©clarĂ© a = b.
Les opĂ©rations d’affectation sont des expressions pouvant ĂŞtre Ă©valuĂ©es. Cela signifie que l’affectation elle-mĂŞme a une valeur et, pour les types fondamentaux, cette valeur est celle affectĂ©e Ă 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 littĂ©ralement Ă leurs opĂ©rateurs mathĂ©matiques respectifs. Le dernier, opĂ©rateur modulo, reprĂ©sentĂ© par un signe de pourcentage (%), donne le reste d’une 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 premiers compilateurs C, les trois expressions précédentes peuvent avoir généré un code exécutable différent selon celle qui a été utilisée. De nos jours, ce type d’optimisation de code est généralement effectué automatiquement par le compilateur, les trois expressions doivent donc produire exactement le même code exécutable.
Une particularitĂ© de cet opĂ©rateur est qu’il peut ĂŞtre utilisĂ© Ă la fois comme prĂ©fixe et comme suffixe. Cela signifie qu’il peut ĂŞtre Ă©crit avant le nom de la variable (++ x) ou après (x ++). Bien que dans des expressions simples comme x ++ ou ++ x, les deux ont exactement la mĂŞme signification; dans d’autres expressions dans lesquelles le rĂ©sultat de l’opĂ©ration d’incrĂ©mentation ou de dĂ©crĂ©mentation est Ă©valuĂ©, elles peuvent avoir une diffĂ©rence de sens importante: dans le cas oĂą l’opĂ©rateur d’augmentation est utilisĂ© comme prĂ©fixe (++ x) de la valeur, l’expression est Ă©valuĂ©e Ă la valeur finale de x, une fois qu’il est dĂ©jĂ augmentĂ©. D’autre part, dans le cas oĂą il est utilisĂ© comme suffixe (x ++), la valeur est Ă©galement augmentĂ©e, mais l’expression est Ă©valuĂ©e Ă la valeur que x avait avant d’ĂŞtre augmentĂ©e. Remarquez la 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
Faites attention! L’opĂ©rateur d’assignation (opĂ©rateur =, avec un signe Ă©gal) n’est pas le mĂŞme que l’opĂ©rateur de comparaison d’Ă©galitĂ© (opĂ©rateur ==, avec deux signes Ă©gaux); le premier (=) assigne la valeur de droite Ă la variable de gauche, tandis que l’autre (==) compare si les valeurs des deux cĂ´tĂ©s de l’opĂ©rateur sont Ă©gales. Par consĂ©quent, dans la dernière expression ((b = 2) == a), nous avons d’abord affectĂ© la valeur 2 Ă b, puis nous l’avons comparĂ©e Ă a (qui stocke Ă©galement la valeur 2), ce qui donne 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 utilisant les opĂ©rateurs logiques, C ++ n’Ă©value que ce qui est nĂ©cessaire de gauche Ă droite pour obtenir le rĂ©sultat relationnel combinĂ©, en ignorant le reste. Par consĂ©quent, dans le dernier exemple ((5 == 5) || (3> 6)), C ++ dĂ©termine d’abord si 5 == 5 est vrai et, dans l’affirmative, il ne vĂ©rifie jamais si 3> 6 est vrai ou non. Ceci est connu sous le nom d’Ă©valuation de court-circuit et fonctionne comme ceci pour ces opĂ©rateurs:
Opérateur   Description
&&         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, a Ă©tait 2 et b Ă©tait 7, donc l’expression en cours d’Ă©valuation (a> b) n’Ă©tait pas vraie. La première valeur spĂ©cifiĂ©e après le point d’interrogation a donc Ă©tĂ© ignorĂ©e au profit de la deuxième valeur (celle qui suit le signe deux-points). ) qui Ă©tait b (avec une valeur de 7).