Opérateurs (C# et Java)

Mise à jour : novembre 2007

C# offre tous les opérateurs appropriés pris en charge par Java. Ceux-ci sont répertoriés dans le tableau suivant. À la fin de la table, vous trouverez de nouveaux opérateurs disponibles en C#, mais pas en Java :

Catégorie	Symbole
Unaire	++--+-!~()
Multiplicative	*/%
Additive	+ -
Décalage	<< >>
Relationnel	< > <= >= instanceof
Égalité	== !=
AND logique	&
XOR logique	^
OR logique	|
AND conditionnel	&&
OR conditionnel	||
Conditionnel	? :
Assignation	= *= /= %= += -= <<= >>= &= ^= |=
Type d'opérande	typeof
Taille d'opérande	sizeof
Appliquer le contrôle de dépassement	checked
Supprimer le contrôle de dépassement	unchecked

Le seul opérateur Java non disponible en C# est l'opérateur de décalage (>>>). Cet opérateur est présent en Java en raison du manque de variables non signées dans ce langage, pour les cas où un décalage vers la droite est requis pour insérer un 1 dans les bits les plus significatifs.

Étant donné que C# prend en charge les variables non signées, C# n'a besoin que de l'opérateur >> standard. Cet opérateur produit des résultats différents selon que l'opérande est signé ou non signé. Le décalage vers la droite d'un nombre non signé entraîne l'insertion de 0 dans le bit le plus significatif, tandis que le décalage vers la droite d'un nombre signé entraîne la copie du bit le plus significatif précédent.

Opérateurs Checked et Unchecked

Les opérations arithmétiques produiront un dépassement de capacité si le résultat est trop grand pour le nombre de bits alloué au type de données en cours d'utilisation. Les dépassements de ce type peuvent être vérifiés ou ignorés pour toute opération arithmétique intégrale donnée à l'aide des mots clés checked et unchecked. Si l'expression est une expression constante qui utilise checked, une erreur est générée au moment de la compilation.

L'exemple simple suivant illustre ces opérateurs :

class TestCheckedAndUnchecked
{
    static void Main()
    {
        short a = 10000;
        short b = 10000;

        short c = (short)(a * b);                     // unchecked by default
        short d = unchecked((short)(10000 * 10000));  // unchecked
        short e = checked((short)(a * b));            // checked - run-time error

        System.Console.WriteLine(10000 * 10000);  // 100000000
        System.Console.WriteLine(c);              // -7936
        System.Console.WriteLine(d);              // -7936
        System.Console.WriteLine(e);              // no result
    }    
}

Dans ce code, l'opérateur unchecked empêche l'erreur de compilation qui serait autrement causée par l'instruction suivante :

short d = unchecked((short)(10000 * 10000));  // unchecked

L'expression suivante est non contrôlée par défaut, et la valeur engendre un dépassement de capacité en mode silencieux :

short c = (short)(a * b);                     // unchecked by default

Nous pouvons forcer l'expression à être contrôlée pour dépassement de capacité au moment de l'exécution avec l'opérateur checked :

short e = checked((short)(a * b));            // checked - run-time error

Assigner les deux premières valeurs à d et c provoque un dépassement de capacité en mode silencieux avec une valeur de -7936 lorsque le programme est exécuté, mais lorsque vous essayez de multiplier la valeur pour e à l'aide de checked(), le programme lève une OverflowException.

Remarque :
Vous pouvez également contrôler s'il faut vérifier la présence d'un dépassement arithmétique dans un bloc de code en utilisant un commutateur de compilateur de ligne de commande (/checked), ou directement dans Visual Studio projet par projet.

Voir aussi

Concepts

Guide de programmation C#

Référence

Opérateurs C#

Autres ressources

Langage de programmation C# pour les développeurs Java