Download WordPress Themes, Happy Birthday Wishes
Accueil » Tutoriels » Programmation » C++ » Les opérateurs dans 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.

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.

À lire aussi  Les Pointeurs dans C++

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


Laisser une réponse

Votre adresse email ne sera pas publiéeLes champs requis sont surlignés *

*

x

Check Also

c, c++, c#, objective-c

C, C ++, C # et Objective-C : quelle différences entre ces langages et comment sont-ils utilisés ?

L’informatique est si vaste que même après avoir obtenu un diplôme ou passé quelques années ...