Programmation C sharp/Les opérateurs

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche
Programmation C#
Programmation C#
Sommaire
Le langage
Programmation avancée
API .Net
Ressources
Modifier ce modèle

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

Une expression booléenne (telle 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[modifier | modifier le wikicode]

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
~ 1001 0011  (0x93)
= 0110 1100  (0x6C)
  • L'opérateur et ne retourne que les bits à 1 communs aux deux opérandes. Exemple : 0x93 & 0x36
  1001 0011  (0x93)
& 0011 0110  (0x36)
= 0001 0010  (0x12)
  • L'opérateur ou retourne les bits à 0 communs aux deux opérandes. Exemple : 0x93 | 0x36
  1001 0011  (0x93)
| 0011 0110  (0x36)
= 1011 0111  (0xB7)
  • 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
  10010011  (0x93)
  010011    <<2
= 01001100  (0x4C)
  • 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
  10010011  (0x93)
    100100  >>2
= 00100100  (0x24)

Le test de type[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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 :

expression is type

Exemple :

 Nombre nombre = new Entier(150);
 if (nombre is Entier)
     Console.WriteLine("nombre entier");

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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 :

(nouveau_type)expression

Exemple :

int longueur = (int)( 10.2 * 3.1415 );

L'opérateur as[modifier | modifier le wikicode]

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 :

expression as nouveau_type

Exemple :

object o = "Chaîne de caractère dérive de la classe object" as object;

Les opérateurs d'affectation[modifier | modifier le wikicode]

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

L'affectation simple[modifier | modifier le wikicode]

L'opérateur = affecte le résultat de l'expression de droite à la variable située à gauche.

Exemples :

total = 0;
total = 1 + 2;
total = longueur + largeur;
this.article1.nom = "Livre";

N.B.: Cet opérateur est le seul opérateur d'affectation utilisable à la déclaration des variables : type identifiant_variable = expression;

Exemples :

int total = 0;
double prix_total_ttc = 1.196 * prix_total_ht;
string nom_article = "Livre";
object livre = new Livre("Sans titre");

L'affectation avec opération[modifier | modifier le wikicode]

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#[modifier | modifier le wikicode]

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)

++ --

+    -
!    ~
(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
<< >> Décalage de bits vers la droite ou vers la gauche
< <=

> >=

Comparaison “ inférieur strictement ” et “ inférieur ou égal ”

Comparaison “ supérieur strictement ” et “ supérieur ou égal ”

== != Condition “ égal ” et “ différent ”
& ET binaire
^ OU exclusif binaire / logique
| OU binaire
&& ET logique booléen
|| OU logique booléen
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

, Séquence d'expressions de gauche à droite

Erreurs dans les expressions[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

Le débordement provoque une exception System.OverflowException.

checked( expression )

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[modifier | modifier le wikicode]

Le débordement provoque une copie partielle (les bits de poids faibles) du résultat de l'expression.

unchecked( 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.