# Programmation C sharp/Les opérateurs

Les opérateurs sont utilisés dans les expressions :
* la plupart d'entre eux nécessitent deux opérandes comme l'addition ( a + b ) et sont appelés opérateurs binaires ;
* d'autres ne nécessitent qu'un seul opérande situé juste après celui-ci tel la négation booléenne ( !ok ) et sont appelés opérateurs unaires ;
* enfin, l'opérateur ?: est le seul opérateur ternaire, c'est à dire nécessitant trois opérandes.

## Les opérateurs arithmétiques

Parmi les opérateurs arithmétiques, il y a les quatre opérateurs de base classiques :
* l'addition : 5 + 2 (7)
* la soustraction : 7 - 5 (2)
* la multiplication : 3 * 4 (12)
* la division : 12 / 4 (3)
Cependant, la division sur deux nombres entiers produit un nombre entier. Le reste de cette division est donné par l'opérateur modulo : 13 % 3 (1, car 13 = 3*4 + 1) La division donnera un nombre à virgule flottante si au moins l'un des deux opérandes est de ce type : 12.0 / 5 donnera 2.4.

## Les opérateurs de comparaison

Chaque opérateur de comparaison retourne un booléen (true ou false) déterminant si la condition est vraie ou fausse :
* L'opérateur d'égalité : a == b
* L'opérateur d'inégalité : a != b
* L'opérateur inférieur à : a < b
* L'opérateur supérieur à : a > b
* L'opérateur inférieur ou égal à : a <= b
* L'opérateur supérieur ou égal à : a >= b

## Les opérateurs booléens

Les expressions booléennes (telles les comparaisons) sont des conditions qui peuvent être combinées avec les opérateurs suivants :
* L'opérateur non retourne le contraire de l'opérande (vrai pour faux, et faux pour vrai). Exemple : !(a==5)
* L'opérateur et ne retourne vrai que si les deux opérandes sont vrais. Exemple : (a==5) && (b==0)
* L'opérateur ou retourne vrai si l'un des deux opérandes est vrai. Exemple : (a==5) || (b==0)
* L'opérateur ou exclusif retourne vrai si un seul des deux opérandes est vrai, c'est à dire qu'il retourne vrai pour les couples d'opérandes (vrai, faux) et (faux, vrai). Comme dans de nombreux langages, il n'existe pas d'opérateur ou-exclusif spécifique. Mais on peut utiliser l'opérateur de comparaison différent pour comparer les valeurs booléennes (false/true). Exemple : (a==5) != (b==0)

## Les opérateurs de manipulation des bits

Les exemples montrent la représentation binaire des opérandes de type octet (byte), donc sur 8 bits.
Les opérateurs suivants manipulent les bits :
* L'opérateur non retourne l'inverse des bits de l'opérande (0 pour 1, et 1 pour 0). Exemple : ~ 0x93
* L'opérateur et ne retourne que les bits à 1 communs aux deux opérandes. Exemple : 0x93 & 0x36
* L'opérateur ou retourne les bits à 0 communs aux deux opérandes. Exemple : 0x93 | 0x36
* L'opérateur de décalage de bits vers la gauche, comme son nom l'indique, décale les bits de l'opérande vers la gauche, du nombre de bits spécifié par le second opérande. Les bits les plus à gauche sont donc perdus. Exemple : 0x93 << 2
* L'opérateur de décalage de bits vers la droite, comme son nom l'indique, décale les bits de l'opérande vers la droite, du nombre de bits spécifié par le second opérande. Les bits les plus à droite sont donc perdus. Exemple : 0x93 >> 2

## Le test de type

Tester le type d'un objet permet de savoir si son type est d'une classe particulière ou une de ses sous-classes. Il permet également de savoir si sa classe implémente une interface particulière.

### L'opérateur is

Cet opérateur permet de tester le type d'un objet. Le premier argument est l'objet à tester, le second doit être un Type. L'opérateur retourne une valeur de type bool : true si l'objet passé est du type spécifié, false sinon.
Syntaxe :
Exemple :
Cet opérateur équivaut à comparer le type retourné par la méthode GetType avec le type spécifié, tout en gérant le cas où la référence d'objet est nulle (null).

## Les opérateurs de conversion

La conversion permet de modifier le type d'une expression ou d'une référence en un autre type (par exemple, convertir l'entier 5 en nombre à virgule flottante). Le langage C# dispose de deux opérateurs différents :

### Les parenthèses

Les parenthèses permettent de convertir tout type en un autre. La conversion d'objet d'une classe en une autre n'est possible que si le type réel de l'expression convertie est une sous-classe du type spécifié, ou implémente l'interface spécifiée. Dans le cas contraire, l'opérateur lance une exception. La syntaxe est la suivante :
Exemple :

### L'opérateur as

Contrairement à l'opérateur précédent, l'opérateur as ne fonctionne que sur les références d'objets. Si la conversion ne peut être effectuée (la nouvelle classe n'est pas une classe de base de la classe réelle, ou n'est pas une interface implémentée par la classe réelle), alors la valeur null est retournée (aucune exception lancée). La syntaxe est la suivante :
Exemple :

## Les opérateurs d'affectation

L'affectation consiste à assigner une valeur (constante ou résultat d'une expression) à une variable.

### L'affectation simple

L'opérateur = affecte le résultat de l'expression de droite à la variable située à gauche.
Exemples :
N.B.: Cet opérateur est le seul opérateur d'affectation utilisable à la déclaration des variables : type identifiant_variable = expression;
Exemples :

### L'affectation avec opération

Un tel opérateur effectue une opération utilisant la valeur actuelle d'une variable et affecte le résultat à cette même variable.
La syntaxe est la suivante :
    variable opérateur = expression
Cette syntaxe est l'équivalent de la suivante :
    variable = variable opérateur expression
Ces opérateurs d'affectation sont les suivants :
| Opérateur | Exemple | Équivalent |
| += | a += 5; | a = a + 5; |
| -= | a -= 5; | a = a - 5; |
| *= | a *= 5; | a = a * 5; |
| /= | a /= 5; | a = a / 5; |
| %= | a %= 5; | a = a % 5; |
| <<= | a <<= 5; | a = a << 5; |
| >>= | a >>= 5; | a = a >> 5; |
| &= | a &= 5; | a = a & 5; |
| ^= | a ^= 5; | a = a ^ 5; |
| |= | a |= 5; | a = a | 5; |
N.B.: Un tel opérateur d'affectation ne peut être utilisé à la déclaration d'une variable car celle-ci n'existe pas encore lors de l'évaluation de l'expression.

## La liste complète des opérateurs du C#

La liste ci-dessous présente les différents opérateurs du language C# avec leur associativité dans l'ordre de leur priorité (du premier évalué au dernier). Les opérateurs situés dans le même bloc ont la même priorité.
Code de couleur :
* Les opérateurs en rouge ne peuvent être surchargés.
* Les opérateurs en bleu ne peuvent être surchargés de la manière classique (mot-clé operator), mais d'une autre manière.
| Opérateurs | Description | Associativité |
| :: | Qualificateur d'alias d'espace de noms | de gauche à droite |
| . -> | Parenthèses pour évaluer en priorité Tableau Sélection d'un membre par un identificateur (structures et objets) Sélection d'un membre par un pointeur (structures et objets) | de gauche à droite |
| ++ -- + - ! ~ (type) * & as is typeof sizeof new | Incrémentation post ou pré-fixée Opérateur moins unaire (change le signe de l'opérande) Non logique et Non binaire Conversion de type Déréférencement Référencement (adresse d'une variable) Conversion de type référence (pas d'exception lancée) Test de type Type d'une variable / expression Taille d'une variable / d'un type Allocation mémoire | de droite à gauche |
| * / % | Multiplication, division, et modulo (reste d'une division) | de gauche à droite |
| + - | Addition et soustraction | de gauche à droite |
| << >> | Décalage de bits vers la droite ou vers la gauche | de gauche à droite |
| < <= > >= | Comparaison “ inférieur strictement ” et “ inférieur ou égal ” Comparaison “ supérieur strictement ” et “ supérieur ou égal ” | de gauche à droite |
| == != | Condition “ égal ” et “ différent ” | de gauche à droite |
| & | ET binaire | de gauche à droite |
| ^ | OU exclusif binaire / logique | de gauche à droite |
| | | OU binaire | de gauche à droite |
| && | ET logique booléen | de gauche à droite |
| || | OU logique booléen | de gauche à droite |
| c?t:f | Opérateur ternaire de condition | de droite à gauche |
| = += -= *= /= %= <<= >>= &= ^= |= | Affectation Affectation avec somme ou soustraction Affectation avec multiplication, division ou modulo Affectation avec décalage de bits Affectation avec ET, OU ou OU exclusif binaires | de droite à gauche |
| , | Séquence d'expressions | de gauche à droite |

## Erreurs dans les expressions

Différents types d'erreur peuvent survenir dans une expression :
* division par zéro : le résultat est indéfini,
* débordement du résultat : le nombre de bits du type accueillant le résultat est insuffisant.
Si l'expression où se situe l'erreur est constante (pas de variable dans l'expression), le résultat est évalué à la compilation, et produit en cas d'erreur une erreur de compilation.
Si au contraire, l'expression n'est pas constante, une erreur provoque le lancement d'une exception.
Ce comportement peut être modifié pour le débordement par les mots-clés checked et unchecked.

### Vérification du débordement

Le débordement provoque une exception System.OverflowException.
Il s'agit du contexte par défaut pour les expressions constantes, c'est à dire celles qui peuvent être évaluées lors de la compilation.

### Non vérification du débordement

Le débordement provoque une copie partielle (les bits de poids faibles) du résultat de l'expression.
Il s'agit du contexte par défaut pour les expressions non constantes, c'est à dire celles qui ne peuvent être évaluées que lors de l'exécution.