5 - Les opérateurs

Ils s'utilisent sur des variables qui représentent en général des nombres.

Le +

Il sert à additionner deux nombres.

1int myInt = 1 + 1;

Après exécution, myInt vaut 2.

Il peut aussi servir pour des chaînes de caractères :

1string s = "deux " + "mots";

Après exécution, s vaut "deux mots".

Dans le code string s = "nombre converti en chaîne de caractères : " + 4;, le nombre 4 est automatiquement converti en une chaîne de caractères qui est mise à la suite de la 1ère.

Le -

Il sert à effectuer une soustraction.

1int myInt = 3 - 4;

Après exécution, myInt vaut -1.

Cela n'aurait pas marché avec un uint car un uint n'est pas signé : il est forcément positif.

Le *

Il sert à effectuer une multiplication.

1int myInt = 2 * 3;

Après exécution, myInt vaut 6.

Le /

Il sert à effectuer une division.

Si les deux opérandes sont des entiers, le résultat est le quotient entier.

1int myInt = 5 / 2;

Ainsi, après exécution, myInt vaut 2.

1double d = 5.0 / 2;

Après exécution, d vaut 2.5. Le fait d'avoir mis un point (qui correspond en français à une virgule) indique que l'on ne veut pas traiter avec des entiers. 2 est bien un entier mais est, ici, automatiquement converti pour que l'opération fonctionne.

Le %

Il permet d'obtenir le reste d'une division euclidienne : si a = b*q + r, avec 0 <= r < q, alors a % b vaut r.

1int myInt = 21 % 10;

Après exécution, myInt vaut 1 car 21 = 2*10 + 1.

Comme dit précédemment, vous n'êtes pas obligés d'utiliser des valeurs fixées. Vous pouvez donc écrire :

1int i = 5;

2int j = i + 7;

Après exécution, i vaut 5 et j vaut 5 + 7 = 12.

Simplifications d'écriture

Il est possible (et préférable) d'écrire :

• i += 5; à la place de i = i + 5;
• i -= 5; à la place de i = i - 5;
• i *= 5; à la place de i = i * 5;
• i /= 5; à la place de i = i / 5;
• i %= 5; à la place de i = i % 5;

Pour simplifier au maximum votre code, plutôt que d'écrirei = i + 1; ou i += 1;écrivezi++;

Cette simplification n'est valable que pour les opérateurs + et - (i--; à la place de i -= 1;).

Priorités des opérateurs

+ et - ont une priorité rigoureusement identique et sont évalués dans l'ordre d'apparition (il en va de même pour * et /, qui en plus sont prioritaires devant + et -). Dans le doute, mettez des parenthèses pour être sûrs des priorités. Pensez aussi à ceux qui vous reliront peut-être : codez de façon claire.

En électronique, ils permettent de comparer deux bits ensemble. Un bit vaut soit 0 (pas de tension) soit 1 (présence de tension).

En C#, ils permettent de comparer deux booléens. Le terme "booléen" vient de George Boole, mathématicien anglais à qui on doit l'algèbre de Boole : théories mathématiques sur les comparaisons d'assertions (une assertion est une proposition pouvant être soit vraie, soit fausse).

En termes binaires:
0 correspond à false (faux)
1 correspond à true (vrai)

Les opérateurs sont représentés par des symboles (ici entre parenthèses). Dans le code vous devez impérativement utiliser les symboles et non pas le nom des opérateurs.

NOT (!)

Opérande	Résultat
false	true
true	false

Le résultat est l'inverse de l'opérande.
Ce qui donne en notation binaire :
!0 = 1
!1 = 0

Cela n'a rien à voir avec n! qui signifie "factorielle n". n! = n*(n-1)*(n-2)* ... 2*1 avec n >= 0 (0! = 1)

AND (&&)

Opérandes	Résultat
false	false	false
false	true	false
true	false	false
true	true	true

Les deux opérandes doivent valoir true pour que le résultat soit true.
0 AND 0 = 0
0 AND 1 = 0
1 AND 0 = 0
1 AND 1 = 1

D'un point de vue électronique, on peut écrire "+" à la place de "OR" et "." (point de la multiplication) à la place de "AND". Vous pouvez regarder des articles sur l'algèbre de Boole pour apprendre à maîtriser les opérateurs logiques.

OR (||)

Opérandes	Résultat
false	false	false
false	true	true
true	false	true
true	true	true

Un au moins des deux opérandes doit valoir true pour que le résultat soit true.
0 OR 0 = 0
0 OR 1 = 1
1 OR 0 = 1
1 OR 1 = 1

XOR (^)

Opérandes	Résultat
false	false	false
false	true	true
true	false	true
true	true	false

C'est un ou exclusif : pareil que pour OR mais si les deux sont true, le résultat sera false.
0 XOR 0 = 0
0 XOR 1 = 1
1 XOR 0 = 1
1 XOR 1 = 0

L'opérateur d'affectation

Le =

La syntaxe est : variableÀModifier = nouvelleValeurDeLaVariable;
Par exemple, si myInt est un entier, l'instruction myInt = 2; remplace la valeur existante de myIntpar 2.

Lignes de code	Résultat
int myInt;	Un espace mémoire est alloué pour stocker la valeur de myInt. À cet instantmyInt n'a pas de valeur.
(lignes intermédiaires)
myInt = 2;	La valeur de myInt est modifiée. myInt vaut à présent 2.

Pour faire une assignation (=affectation), on peut aussi utiliser une autre variable ; la syntaxe est alors :variableÀModifier = autreVariable;

Il faut que les deux variables soient de même type.

Que se passe-t-il à l'exécution ?

En fait cela dépend. Si les variables sont de type valeur, on récupère la valeur de autreVariable et on l'écrit en mémoire là où est stockée variableÀModifier.
Si autreVariable ne contient pas une valeur mais une référence, alors les deux variablesvariableÀModifier et autreVariable vont référencer le même objet.
Après l'affectation variableÀModifier = autreVariable;, si l'une des deux variables est modifiée, l'autre le sera donc aussi.

Les opérateurs de comparaison

Opérateur ==

Il retourne true si les deux opérandes sont égaux et false si ce n'est pas le cas.

1bool numbersAreEqual = (2 == 5);

2 n'est pas égal à 5 donc après exécution numbersAreEqual vaut false.

L'absence de parenthèses ne provoque pas d'erreur, mais autant les mettre car cela rend votre code plus lisible.

Opérateur !=

Il retourne true si les deux opérandes sont différents et false si ce n'est pas le cas.

1bool numbersAreDifferent = (2 != 5);

2 n'est pas égal à 5 donc après exécution numbersAreDifferent vaut true.

Opérateurs d'inégalités

Vous les connaissez, ce sont des opérateurs mathématiques simples :

• < (inférieur)
• <= (inférieur ou égal)
• > (supérieur)
• >= (supérieur ou égal)

L'opérateur ternaire "?"

Il s'utilise de cette façon : a ? b : c;.
a doit être une expression conditionnelle (qui retourne true ou false). À l'exécution, cette expression est évaluée.
Si elle vaut true, l'expression b sera exécutée et son résultat sera retourné ; l'expression c sera ignorée.
Si elle vaut false, l'expression c sera exécutée et son résultat sera retourné ; l'expression b sera ignorée.

Voici un exemple :

1string myString = (2 == 5) ? "les nombres sont égaux" : "les nombres ne sont pas égaux";

Après exécution, myString vaut "les nombres ne sont pas égaux" car (2 == 5) a retournéfalse.

Mémorisez bien tous ces hiéroglyphes car vous en aurez tout le temps besoin !