Événements
Créer des applications intelligentes
17 mars, 23 h - 21 mars, 23 h
Rejoignez la série de rencontres pour créer des solutions IA évolutives basées sur des cas d’usage réels avec d’autres développeurs et experts.
S’inscrire maintenantCe navigateur n’est plus pris en charge.
Effectuez une mise à niveau vers Microsoft Edge pour tirer parti des dernières fonctionnalités, des mises à jour de sécurité et du support technique.
Les opérateurs suivants effectuent des opérations arithmétiques avec des opérandes de types numériques :
++
(incrément), --
(décrément), +
(plus) et -
(moins)*
(multiplication), /
(division), %
(reste), +
(addition) et -
(soustraction)Ces opérateurs sont pris en charge par tous les types numériques intégraux et à virgule flottante.
Dans le cas des types intégraux, ces opérateurs (à l’exception des opérateurs ++
et --
) sont définis pour les types int
, uint
, long
et ulong
. Lorsque les opérandes sont d’autres types intégraux (sbyte
, byte
, short
, ushort
ou char
), leurs valeurs sont converties en valeurs de type int
, qui est également le type de résultat d’une opération. Lorsque des opérandes sont de types intégraux ou à virgule flottante différents, leurs valeurs sont converties en type contenant le plus proche, s’il existe un tel type. Pour plus d’informations, consultez la section Promotions numériques de la spécification du langage C#. Les opérateurs ++
et --
sont définis pour tous les types numériques intégraux et à virgule flottante, ainsi que pour le type char . Le type de résultat d’une expression d’affectation composée est le type de l’opérande de gauche.
L’opérateur d’incrémentation unaire ++
incrémente son opérande de 1. L’opérande doit être une variable, un accès propriété ou un accès indexeur.
L’opérateur d’incrémentation est pris en charge sous deux formes : l’opérateur d’incrémentation suffixé, x++
, et l’opérateur d’incrémentation préfixé, ++x
.
Le résultat de x++
est la valeur de x
avant l’opération, comme le montre l’exemple suivant :
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i); // output: 4
Le résultat de ++x
est la valeur de x
après l’opération, comme le montre l’exemple suivant :
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a); // output: 2.5
L’opérateur de décrémentation unaire --
décrémente son opérande de 1. L’opérande doit être une variable, un accès propriété ou un accès indexeur.
L’opérateur de décrémentation est pris en charge sous deux formes : l’opérateur de décrémentation suffixé, x--
, et l’opérateur de décrémentation préfixé, --x
.
Le résultat de x--
est la valeur de x
avant l’opération, comme le montre l’exemple suivant :
int i = 3;
Console.WriteLine(i); // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i); // output: 2
Le résultat de --x
est la valeur de x
après l’opération, comme le montre l’exemple suivant :
double a = 1.5;
Console.WriteLine(a); // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a); // output: 0.5
L’opérateur unaire +
retourne la valeur de son opérande. L’opérateur unaire -
calcule la négation numérique de son opérande.
Console.WriteLine(+4); // output: 4
Console.WriteLine(-4); // output: -4
Console.WriteLine(-(-4)); // output: 4
uint a = 5;
var b = -a;
Console.WriteLine(b); // output: -5
Console.WriteLine(b.GetType()); // output: System.Int64
Console.WriteLine(-double.NaN); // output: NaN
Le type ulong ne prend pas en charge l’opérateur unaire -
.
L’opérateur de multiplication *
calcule le produit de ses opérandes :
Console.WriteLine(5 * 2); // output: 10
Console.WriteLine(0.5 * 2.5); // output: 1.25
Console.WriteLine(0.1m * 23.4m); // output: 2.34
L’opérateur unaire *
est l’opérateur d’indirection de pointeur.
L’opérateur de division /
divise son opérande de partie gauche par son opérande de partie droite.
Pour les opérandes des types entiers, le résultat de l’opérateur /
est de type entier et égal au quotient de deux opérandes arrondis vers le zéro :
Console.WriteLine(13 / 5); // output: 2
Console.WriteLine(-13 / 5); // output: -2
Console.WriteLine(13 / -5); // output: -2
Console.WriteLine(-13 / -5); // output: 2
Pour obtenir le quotient de deux opérandes comme un nombre à virgule flottante, utilisez le type float
, double
ou decimal
:
Console.WriteLine(13 / 5.0); // output: 2.6
int a = 13;
int b = 5;
Console.WriteLine((double)a / b); // output: 2.6
Pour les types float
, double
et decimal
, le résultat de l’opérateur /
est le quotient de deux opérandes :
Console.WriteLine(16.8f / 4.1f); // output: 4.097561
Console.WriteLine(16.8d / 4.1d); // output: 4.09756097560976
Console.WriteLine(16.8m / 4.1m); // output: 4.0975609756097560975609756098
Si l’un des opérandes est decimal
, un autre opérande ne peut être float
ni double
, car ni float
ni double
ne sont implicitement convertibles en decimal
. Vous devez convertir explicitement l’opérande float
ou double
en type decimal
. Pour plus d’informations sur les conversions entre des types numériques, consultez Conversions numériques intégrées.
L’opérateur restant %
calcule le reste après la division de son opérande de partie gauche par son opérande de partie droite.
Pour les opérandes des types entiers, le résultat de a % b
est la valeur produite par a - (a / b) * b
. Le signe du reste non zéro est le même que celui du signe de l’opérande de partie gauche, comme l’indique l’exemple suivant :
Console.WriteLine(5 % 4); // output: 1
Console.WriteLine(5 % -4); // output: 1
Console.WriteLine(-5 % 4); // output: -1
Console.WriteLine(-5 % -4); // output: -1
Utilisez la méthode Math.DivRem pour calculer à la fois la division entière et les résultats du reste.
En ce qui concerne les opérandes float
et double
, le résultat de x % y
pour le x
et le y
finis est la valeur z
afin que
z
, s’il est différent de zéro, soit identique au signe de x
.z
soit la valeur produite par |x| - n * |y|
, où n
représente le plus grand entier possible inférieur ou égal à |x| / |y|
, et où |x|
et |y|
sont les valeurs absolues de x
et y
, respectivement.Notes
Cette méthode de calcul du reste est analogue à celle utilisée pour les opérandes entiers. Toutefois, elle ne suit pas la spécification IEEE 754. Si l’opération de reste doit être conforme à la spécification IEEE 754, utilisez la méthode Math.IEEERemainder.
Pour plus d’informations sur le comportement de l’opérateur %
avec des opérandes non finis, consultez la section Opérateur de reste dans la Spécification du langage C#.
Pour les opérandes decimal
, l’opérateur de reste %
équivaut à l’opérateur de reste de type System.Decimal.
L’exemple suivant illustre le comportement de l’opérateur de reste pour les opérandes à virgule flottante :
Console.WriteLine(-5.2f % 2.0f); // output: -1.2
Console.WriteLine(5.9 % 3.1); // output: 2.8
Console.WriteLine(5.9m % 3.1m); // output: 2.8
L’opérateur d’addition +
calcule la somme de ses opérandes :
Console.WriteLine(5 + 4); // output: 9
Console.WriteLine(5 + 4.3); // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3
Vous pouvez également utiliser l’opérateur +
pour la concaténation de chaînes et la combinaison de délégués. Pour plus d’informations, consultez l’article +
et +=
, opérateurs.
L’opérateur de soustraction -
soustrait son opérande de partie droite de son opérande de partie gauche :
Console.WriteLine(47 - 3); // output: 44
Console.WriteLine(5 - 4.3); // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2
Vous pouvez également utiliser l’opérateur -
pour la suppression de délégués. Pour plus d’informations, consultez l’article -
et -=
, opérateurs.
Pour un opérateur binaire op
, une expression d’assignation composée du formulaire
x op= y
équivaut à :
x = x op y
sauf que x
n’est évalué qu’une seule fois.
L’exemple suivant illustre l’utilisation de l’assignation composée avec des opérateurs arithmétiques :
int a = 5;
a += 9;
Console.WriteLine(a); // output: 14
a -= 4;
Console.WriteLine(a); // output: 10
a *= 2;
Console.WriteLine(a); // output: 20
a /= 4;
Console.WriteLine(a); // output: 5
a %= 3;
Console.WriteLine(a); // output: 2
En raison des promotions numériques, le résultat de l’opération op
risque de ne pas être implicitement convertible en type T
de x
. Dans ce cas, si op
est un opérateur prédéfini et que le résultat de l’opération est explicitement convertible en type T
de x
, une expression d’assignation composée de la forme x op= y
équivaut à x = (T)(x op y)
, sauf que x
n’est évalué qu’une seule fois. L’exemple suivant illustre ce comportement :
byte a = 200;
byte b = 100;
var c = a + b;
Console.WriteLine(c.GetType()); // output: System.Int32
Console.WriteLine(c); // output: 300
a += b;
Console.WriteLine(a); // output: 44
Dans l’exemple précédent, la valeur 44
est le résultat de la conversion de la valeur 300
en type byte
.
Notes
Dans le contexte de vérification de dépassement de capacité vérifié, l’exemple précédent lève un OverflowException. Pour plus d’informations, consultez la section Dépassement arithmétique entier.
Vous utilisez également les opérateurs +=
et -=
pour vous abonner d’un événements puis vous désabonner, respectivement. Pour plus d’informations, consultez Guide pratique pour s’abonner et annuler l’abonnement à des événements.
La liste suivante présente les opérateurs arithmétiques de la priorité la plus élevée à la plus basse :
x++
et de décrémentation x--
++x
et de décrémentation --x
et opérateurs unaires +
et -
*
, /
et %
+
et -
Les opérateurs arithmétiques binaires sont associatifs sur leur gauche. Autrement dit, les opérateurs de même niveau de priorité sont évalués de gauche à droite.
Utilisez des parenthèses, ()
, pour modifier l’ordre d’évaluation imposé par la priorité et l’associativité de l’opérateur.
Console.WriteLine(2 + 2 * 2); // output: 6
Console.WriteLine((2 + 2) * 2); // output: 8
Console.WriteLine(9 / 5 / 2); // output: 0
Console.WriteLine(9 / (5 / 2)); // output: 4
Pour obtenir la liste complète des opérateurs C# classés par niveau de priorité, consultez la section Priorité des opérateurs de l’article Opérateurs C#.
Quand le résultat d’une opération arithmétique n’est pas compris dans la plage de valeurs finies possibles du type numérique impliqué, le comportement d’un opérateur arithmétique varie selon le type de ses opérandes.
La division d'un entier par zéro lève toujours une exception DivideByZeroException.
Si un dépassement arithmétique entier se produit, un contexte de vérification de débordement, qui peut être vérifié ou non vérifié, contrôle le comportement qui en résulte :
Avec les instructions vérifiées et non vérifiées, vous pouvez utiliser les opérateurs checked
et unchecked
pour contrôler le contexte de vérification de dépassement, dans lequel une expression est évaluée :
int a = int.MaxValue;
int b = 3;
Console.WriteLine(unchecked(a + b)); // output: -2147483646
try
{
int d = checked(a + b);
}
catch(OverflowException)
{
Console.WriteLine($"Overflow occurred when adding {a} to {b}.");
}
Par défaut, les opérations arithmétiques se produisent dans un contexte unchecked.
Les opérations arithmétiques avec les types float
et double
ne lèvent jamais d’exceptions. Le résultat des opérations arithmétiques avec ces types peut être une des valeurs spéciales qui représentent l’infini et non un nombre :
double a = 1.0 / 0.0;
Console.WriteLine(a); // output: Infinity
Console.WriteLine(double.IsInfinity(a)); // output: True
Console.WriteLine(double.MaxValue + double.MaxValue); // output: Infinity
double b = 0.0 / 0.0;
Console.WriteLine(b); // output: NaN
Console.WriteLine(double.IsNaN(b)); // output: True
Pour les opérandes du type decimal
, le dépassement arithmétique lève toujours un OverflowException. La division d'un nombre par zéro lève toujours une exception DivideByZeroException.
En raison des limitations générales de la représentation à virgule flottante des nombres réels et de l’arithmétique à virgule flottante, des erreurs d’arrondi peuvent se produire dans les calculs avec les types à virgule flottante. Autrement dit, le résultat d’une expression peut différer du résultat mathématique attendu. L’exemple suivant illustre plusieurs cas de ce genre :
Console.WriteLine(.41f % .2f); // output: 0.00999999
double a = 0.1;
double b = 3 * a;
Console.WriteLine(b == 0.3); // output: False
Console.WriteLine(b - 0.3); // output: 5.55111512312578E-17
decimal c = 1 / 3.0m;
decimal d = 3 * c;
Console.WriteLine(d == 1.0m); // output: False
Console.WriteLine(d); // output: 0.9999999999999999999999999999
Pour plus d’informations, consultez les remarques dans les pages de référence System.Double, System.Single ou System.Decimal.
Un type défini par l’utilisateur peut surcharger les opérateurs arithmétiques unaires (++
, --
, +
et -
) et binaires (*
, /
, %
, +
et -
). Quand un opérateur binaire est surchargé, l’opérateur d’assignation composée correspondant est aussi implicitement surchargé. Un type défini par l’utilisateur ne peut pas surcharger explicitement un opérateur d’assignation composée.
À compter de C# 11, lorsque vous surchargez un opérateur arithmétique, vous pouvez utiliser le mot clé checked
pour définir la version vérifiée de cet opérateur. L’exemple suivant montre comment effectuer cette opération :
public record struct Point(int X, int Y)
{
public static Point operator checked +(Point left, Point right)
{
checked
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
public static Point operator +(Point left, Point right)
{
return new Point(left.X + right.X, left.Y + right.Y);
}
}
Lorsque vous définissez un opérateur vérifié, vous devez également définir l’opérateur correspondant sans le modificateur checked
. L’opérateur vérifié est appelé dans un contexte vérifié; l’opérateur sans le checked
modificateur est appelé dans un contexte non vérifié. Si vous fournissez uniquement l’opérateur sans le modificateur checked
, il est appelé à la fois dans un contexte checked
et unchecked
.
Lorsque vous définissez les deux versions d’un opérateur, il est attendu que leur comportement diffère uniquement lorsque le résultat d’une opération est trop grand pour être représenté dans le type de résultat comme suit :
checked
retourne une instance représentant un résultat tronqué.Pour plus d’informations sur la différence de comportement des opérateurs arithmétiques intégrés, consultez la section Dépassement arithmétique et division par zéro.
Vous pouvez utiliser le modificateur checked
uniquement lorsque vous surchargez l’un des opérateurs suivants :
++
, --
et -
*
, /
, +
et -
Notes
Le contexte de contrôle de dépassement dans le corps d’un opérateur vérifié n’est pas affecté par la présence du modificateur checked
. Le contexte par défaut est défini par la valeur de l’option de compilateur CheckForOverflowUnderflow. Utilisez les instructions unchecked
et checked
pour spécifier explicitement le contexte de vérification de dépassement de capacité, comme le montre l’exemple au début de cette section.
Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :
Commentaires sur .NET
.NET est un projet open source. Sélectionnez un lien pour fournir des commentaires :
Événements
Créer des applications intelligentes
17 mars, 23 h - 21 mars, 23 h
Rejoignez la série de rencontres pour créer des solutions IA évolutives basées sur des cas d’usage réels avec d’autres développeurs et experts.
S’inscrire maintenant