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.
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 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).
