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