Opérateurs et Expressions

Un opérateur effectue un traitement et fournit un résultat. Ce résultat a un type.

2.5 + 4.6 = 7.1

Traitement = addition
Résultat = 7.1
Type = double

Un opérateur fonctionne sur les opérandes. Selon le nombre de ses opérandes, il peut être :

unaire (1 opérande) : -x 
binaire (2 opérandes) : x - 3, x=6, a == b
ternaire (3 opérandes) : (x>0) ? x :-x

Comme l'on peut le remarquer, un opérande peut être :

une constante : 6.5, 'A', -2
une variable : x, Car, Nombre
une expression : x+2.5, Car>'A'

Valeurs logiques (booléennes)

En C++, le type booléen (défini en cours d'algorithmique) n'existe pas séparément : il est implémenté par les valeurs numériques.
La valeur Zéro est considérée comme FAUX.
Toutes les valeurs non-zéro sont considérées comme VRAI.

Le résultat d'un test (comme a==b) peut être 0 (FAUX) ou 1 (VRAI)

Exemple :

const int VRAI=1;
const int FAUX=0;
int ElleEstAdulte;
if (Age>18) ElleEstAdulte = VRAI; else ElleEstAdulte = FAUX;

Opérateurs arithmétiques : + - * / %

op1/op2 calcule la division réelle (virgule flottante) si au moins un des opérandes op1 ou op2 sont de type double. Sinon, il calcule la division entière.

op1 % op2 calcule le reste de la division entière.

17/5=3
17%5=2
17.0/5.0=3.4

Opérateurs de comparaison : > < >= <= == !=

Le résultat de la comparaison est une valeur entière, qui est 0 quand la condition est fausse et 1 quand elle est vraie.

Exemple :

int AnneeEstBissextile;
AnneeEstBissextile = (Annee % 4 == 0);
if (AnneeEstBissextile)...

Opérateurs logiques : && || !

&& signifie et
|| signifie ou
! signifie non

Ces opérateurs fonctionnent sur les valeurs numériques en les considérant comme des valeurs logiques (booléennes) et le résultat est une valeur logique : 0 (FAUX) ou 1 (VRAI)

6 && 10 = 1
6 || 10 = 1
! 10 =0

Avec les opérateurs && et ||, l'opérande de droite n'est pas évalué si la valeur de l'opérande de gauche détermine clairement le résultat. Cela arrive dans les deux cas suivants :

0 && x = 0
1 || x = 1

Exemple :

int N = 6; char Car = '5';                
if ((N > 10) && (x + y > 5))
if ((N >= 4) || (N < 1))
if ((Car >= 'A') && (Car <= 'Z'))
(x+y>5) n'est pas exécuté
(N <1) n'est pas exécuté
(Car <= 'Z') n'est pas exécuté

Opérateurs bit à bit : & | ^ ~

Ces opérateurs fonctionnent sur la représentation binaire des opérandes de manière bit à bit. Ils représentent les fonctions booléennes suivantes :

& et 
| ou
^ ou exclusif
~ négation

6 00000110
10 00001010
6 & 10 = 2 00000010
6 | 10 = 14 00001110
6 ^ 10 = 12  00001100
~ 6 = -7 11111001

Opérateurs de décalage : >> <<

Ces opérateurs décalent la représentation binaire de l'opérande à droite ou à gauche.

10 00001010
10 << 1 = 20  00010100
10 << 3 = 80 01010000
10 >> 1 = 5 00000101
10 >> 2 = 2 00000010

Opérateurs d'affectation : =, +=, -=, *=, /=, %=, &=, |=, ^=

Opérateur =

Pour cet opérateur, l'opérande de gauche doit être une variable, et l'opérande de droite est une expression. Le format général est donc :

Variable = Expression

traitement : mettre la valeur de l'expression dans la variable (affectation)
résultat : la valeur de l'expression
type : le même type que la variable

Exemple :

int N;
N = 12;

Opérateurs += -= *= /= %= &= |= ^=

Les opérateurs de type op= peuvent être considérés (dans la plupart des cas) comme des abréviations :

Variable X= Expression ==> Variable = Variable X Expression

Exemples :

N /= 2; revient à N = N/2
Compteur += 1; revient à Compteur = Compteur +1

Opérateurs d'incrémentation : ++ --

Ces opérateurs sont unaires. Ils peuvent apparaître avant ou après l'opérande.

Variable ++ Variable -- ++ Variable -- Variable

L'opérande doit être une variable. Il ne peut pas être une valeur constante.

    traitement résultat expression équivalente
++Var pré-incrémentation Var = Var + 1 Var après le calcul Var = Var + 1
Var++ post-incrémentation Var = Var + 1 Var avant le calcul Tmp = Var, Var = Var + 1, Tmp
--Var pré-décrémentation Var = Var - 1 Var après le calcul Var = Var - 1 
Var-- post-décrémentation Var = Var - 1 Var avant le calcul Tmp = Var, Var = Var - 1, Tmp

Si le résultat n'est pas utilisé, les deux formes Var++ et ++Var sont équivalentes parce qu'ils font le même traitement. Idem pour Var-- et --Var.

Opérateur conditionnel : ?

Condition ? Expression1 : Expression2

La condition est d'abord évaluée. Si elle est vraie, l'expression1 est évaluée et sa valeur est utilisée comme le résultat final, sinon la valeur de l'expression2 est considérée comme le résultat final.

if (Condition) Résultat = Expression1; else Résultat = Expression2;

Type d'opération

Un opérateur peut effectuer des traitements différents selon les types de ces opérandes.

Exemple :

17 / 5 est une division entière
17.0 / 5.0 est une division réelle

Type des opérandes et du résultat

Opérateur opérande gauche opérande droite résultat
+ - * / int int int
+ - * /  double double double
% int int int
&& || int int int (0,1)
< > == >= <= != char char int (0,1)
< > == >= <= != int int int (0,1)
< > == >= <= != double double int (0,1)
= char (variable) char char
= int (variable) int  int
= double (variable) double double

Si les types des opérandes d'un opérateur correspondent à un des cas déjà définis pour lui (tableau ci-dessus), l'opération est effectuée selon les types déclarés pour ce cas.

Sinon, le compilateur essaiera d'appliquer implicitement des conversions de types pour arriver à un des cas définis pour l'opérateur.

Conversions explicites

Ce genre de conversion de type peut être utilisé pour effectuer des conversions qui ne seront pas faites implicitement par le compilateur.

Il y a deux syntaxes possibles pour les conversions de type : une qui est héritée de C et l'autre qui est propre au C++. Il vaut mieux utiliser la syntaxe de C++ qui est plus claire et plus cohérente avec d'autres éléments du langage C++.

C++ : type (Expression)
C : (type) Expression