C# : Les opérateurs de base : Langage C#

Vous verrez qu'il existe un certain nombre d'opérateurs différents et que ceux-ci varient en fonction des types de variables à manipuler. Dans ce chapitre, je n'aborderai que les opérateurs de base. Une liste complète est disponible ici.

Les opérateurs mathématiques

Les opérateurs mathématiques permettent, comme leur nom l'indique, d'effectuer des opérations mathématiques. Rien de bien révolutionnaire, donc. D'ailleurs, si vous êtes allé à l'école quand vous étiez petit, vous les avez sûrement vu, pour la plupart. Ces opérateurs manipulent des variables de types numériques (short, int, long, double, float etc.).

Addition et soustraction

Sans surprise, l'opérateur + et l'opérateur - permettent respectivement d'additionner et de soustraire des nombres:

int a = 3 + 4; // a contient 7
int b = a - 2; // b contient 5

Comme on le voit, ces opérateurs, comme tous les opérateurs, sont utilisables sur les valeurs aussi bien que sur les variables contenant des valeurs.

Multiplication et division

De même, la multiplication et la division sont disponibles. Attention toutefois, le signe réservé à la division est la barre oblique simple / alors que le signe de la multiplication est l'étoile *.

int c = 3 * 4; // c contient 12
int d = c / 2; // d contient 6

Le modulo

Invité surprise de ces opérateurs mathématiques : le modulo. Il s'agit du reste de la division euclidienne entre deux nombres. Par exemple, le modulo de 12 et de 5 est de 2 car 5 * 2 = 10 et 12 - 10 = 2

Moins utilisé que les autres opérateurs mathématiques dans l'enseignement primaire et secondaire, il l'est beaucoup plus en informatique !

Priorités

Comme pour des opérations mathématiques normales, les opérateurs s'exécutent dans un ordre priorité (le modulo, la multiplication et la division s'exécutent avant l'addition et la soustraction). Cet ordre de priorité peut être modifié au moyen de parenthèses et permettre des opérations complexes :

int e = ((3 + 4) * 2 + 1 * 4) / 3; // e contient 6

 

Les opérateurs de comparaison

Assez connus également, certains opérateurs permettent de comparer des nombres, c'est-à-dire de vérifier si tel nombre est plus grand ou moins grand ou égal à un autre. Ces opérateurs renvoient une information simple sous la forme d'un booléen (true ou false) selon si la comparaison est vraie ou fausse. Voyons cela ensemble.

Inégalités

Supérieur à

Pour déterminer si un nombre est supérieur à un autre, l'opérateur à utiliser est > :

bool condition1 = 1 > 2; // condition1 contient false (faux)
bool condition2 = 2 > -6; // condition2 contient true (vrai)

Dans cet exemple, la variable condition1 contient la valeur false car l'expression 1 > 2 est fausse. À l'inverse, 2 > -6 est vrai donc condition2 contient true.

L'inégalité ici testée est une inégalité stricte. C'est-à-dire que le premier nombre doit être strictement supérieur au deuxième. Il existe aussi un opérateur pour tester l'inégalité souple : il s'agit du >= qui est la succession d'un signe supérieur à et d'un signe égal. D'ailleurs, il signifie supérieur ou égal.

int a = 6;
bool condition3 = 7 >= a; // condition3 contient true
bool condition4 = 6 >= a; // condition3 contient true
bool condition5 = 5 >= a; // condition4 contient false

Inférieur à

À l'inverse, inférieur à correspond à l'opérateur < en comparaison stricte et <= en comparaison souple.

int b = 15;
bool condition6 = 14 < b; // true
bool condition7 = 15 < b; // false
bool condition8 = 15 <= b; // true
bool condition9 = 16 < b; // false

Égalités

Il est possible de vérifier si deux nombres (ou variables contenant des nombres) sont égaux. Attention, vous pourriez être tentés d'utiliser l'opérateur = pour cela. N'en faites rien ! L'opérateur permettant de tester l'égalité entre deux nombres est le double égal ==. La raison de est tout simple, le signe égal simple = est déjà utilisé pour l'assignation de valeur (voir plus loin).

Il est également possible de tester la condition inverse, c'est-à-dire tester qu'une valeur est différente d'une autre à l'aide de l'opérateur != (différent de)

int d = 7;
bool condition12 = 10 != d; // false
bool condition13 = 7 != d; // vrai

Les opérateurs logiques

Les nombres ne sont pas les seuls à avoir le droit à leurs opérateurs. Les booléens y ont également droit. En effet, il est possible de lier entre elles des conditions de façon logique comme nous allons le voir.

L'opérateur ET : &&

Il est possible de vérifier si deux ou plusieurs conditions (plusieurs booléens en fait) sont vrai(e)s en même temps. Pour cela, il faut utiliser l'opérateur && qui signifie ET (ou AND).

int a = 10;
int b = 17;
int c = -1;
bool condition1 = a >= 10 && b < 20; // contient true
bool condition2 = a >= 10 && b < 20 && c > 0; // contient false

Dans l'exemple précédent, la première condition est vrai car les deux sous-conditions liées entre elles par un && sont vraies. En revanche, la deuxième est fausse car l'une d'entre elles est fausse.

Retenez ceci : Pour qu'un groupe de condition ET soit vrai, il faut que toutes ses sous-conditions soient vraies.

L'opérateur OU : ||

En revanche, il existe un opérateur vérifiant si au moins une des conditions est vraie : l'opérateur || qui signifie OU (ou OR)

int a = 10; 
int b = 17;
int c = -1; 
bool condition1 = a >= 10 || b > 20; // contient vrai
bool condition2 = a <= 7 || b > 20 || c > 0; // contient false

condition1 est vraie car l'une des conditions est vraie. En revanche, condition2 est fausse car toutes les conditions sont fausses.

Retenez ceci : Pour qu'un groupe de condition OR soit vrai, il suffit qu'une de ses sous-conditions soit vraie.

Inverser une condition : !

Sachez qu'il est aussi possible d'inverser une condition au moyen de l'opérateur !. Inverser une condition signifie la rendre vraie si elle est fausse et la rendre fausse si elle est vraie (vous me suivez ? )

Un exemple :

int a = 10; 
int b = 17;
int c = -1; 
bool condition5 = ! condition1;
// condition5 vaut false
bool condition6 = ! (a > 10 && b >= 17 && c < 0);
// condition6 vaut true

La concaténation

Devinez quoi ? La chaine de caractère a elle aussi droit à son opérateur ! Celui-ci s'appelle l'opérateur de concaténation, il prend le signe + et le moins qu'on puisse dire, c'est qu'il est très utile : Cet opérateur permet en effet d'ajouter plusieurs chaines de caractères les unes à la suite des autres :

string chaine1 = " World!";
string chaine2 = "Hello,";
string hw = chaine2 + chaine1;
// hw contient maintenant "Hello, World!"

Notez que le signe de la concaténation est le même que le signe de l'addition (signe +). C# est suffisamment intelligent pour choisir la bonne opération grâce au type des valeurs entrant en jeu. Si les valeurs liées par un plus sont des nombres, c'est l'addition qui est choisie, si ce sont des chaines de caractères, c'est la concaténation qui s'applique.

Je ne saurai trop vous dire à quel point la concaténation est utile et son usage fréquent.

Les opérateurs d'assignation

L'assignation

Nous avons déjà vu l'opérateur d'assignation : c'est celui qui est utilisé pour déclarer une variable, c'est à dire le signe égal =. En effet, quand on déclare une variable, on lui assigne une valeur.

On peut également l'utiliser pour réassigner, donc donner une nouvelle valeur à une variable. Notez que pour la réassignation, il ne faut pas repréciser le type de la variable.

int a = 12;
// a vaut 12;
a = 18; // le type de la variable ne doit pas être reprécisé
// a vaut maintenant 18

La réassignation

Il est possible de donner une valeur à une variable dépendant de sa valeur précédente. Procéder ainsi est extrêmement utile dans bien des cas. Vous pouvez déjà deviner comment faire :

int b = 7; 
// b vaut 7
b = b + 2; 
// b vaut maintenant 9

Dans l'exemple ci-dessus, on utilise ajoute 2 à la valeur de b et on réassigne cette valeur à b. Ce faisant, on augmente la valeur de b de 2. Ce genre d'opération est évidemment possible avec toutes les opérations mathématiques :

int c = 10;
c = c * 10; 
// c vaut 100

float d = 10f;
d = d / 4;
// d vaut 2,5

int e = 5;
e = e - 3;
// e vaut 2

int f = 14;
f = f % 4;
// f vaut 2

int e = 5;
e = e * 3; 
// e vaut 15

Les raccourcis de la réassignation

Cela dit, il existe des raccourcis pour rendre ces opérations de réassignation plus rapide à écrire. Ce sont les opérateurs de réassignation +=, -=, *=, /= et %=

Ainsi, l'expression

a = a + 2;

peut s'écrire :

a += 2; // signifie a = a + 2

On voit bien ici que l'expression ajoute et réassigne est condensée dans le signe +=. De manière analogue, ce raccourci existe pour tous les opérateurs mathématiques :

int b = 7; 
// b vaut 7
b += 2; 
// b vaut maintenant 9

int c = 10;
c *= 10; 
// c vaut 100

float d = 10f;
d /= 4;
// d vaut 2,5

int e = 5;
e -= 3;
// e vaut 2

int f = 14;
f %= 4;
// f vaut 2

int g = 5;
g *= 3;
// g vaut 15

Cerise sur le gâteau : la concaténation aussi a droit à son raccourci !

string hello = "Hello,";
hello += " World!";
// hello contient "Hello, World!"

Les super raccourcis : l'incrémentation et le décrémentation

Comme vous le savez désormais, on peut augmenter la valeur d'une variable en écrivant ceci :

a = a + 3;

ou encore ceci

a += 3;

Mais il existe un super raccourci permettant d'augmenter la valeur de 1. Vous pensiez que cette écriture était un raccourci suffisant ?

a += 1; // augmente la valeur de a de 1

Détrompez-vous, les informaticiens (des gros fainéants) ont eu l'idée de créer l'opérateur ++ qui permet de faire la même chose :

a++; // augmente aussi a de 1

L'incrémentation de 1 n'est néanmoins pas la seule à posséder son raccourci : la décrémentation aussi ! En toute logique, c'est l'opérateur -- qui est utilisé !

a--; // diminue a de 1

Voilà quelques notations un peu bizarre mais qui, vous vous en doutez, ont leur raison d'être. Si de tels raccourci existent, c'est bien entendu parce que leur usage est on ne peut plus fréquent.

 

Conclusion

Savoir manipuler des variables à l'aide d'opérateurs est un des principes essentiel de la programmation. Je vous ai fourni ici les opérations de bases, c'est-à-dire le kit de survie dans le monde parfois hostile de la programmation. Il existe beaucoup d'autres opérateurs en C#. Ce langage vous permet même de faire quelque chose que j'apprécie beaucoup : la surcharge d'opérateur. Mais cela fait partie de notions plus avancées et que nous verrons dans un autre chapitre.