C++

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.

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.

Ă€ lire aussi  Pourquoi vous devez apprendre le C ++ ?

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.

Ă€ lire aussi  Structures des donnĂ©es dans C++

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


Articles similaires

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Bouton retour en haut de la page