Effectuer des opérations mathématiques
Tip
Pour plus d’informations, consultez l’onglet Texte et images !
À leur cœur, les ordinateurs sont des calculatrices incroyablement rapides. C# prend en charge toutes les opérations mathématiques standard attendues, ce qui vous permet d’effectuer des calculs et d’enregistrer les résultats dans les variables.
Opérateurs arithmétiques
C# utilise des symboles standard pour les mathématiques de base :
| Opérateur | Action | Example | Résultat |
|---|---|---|---|
+ |
Addition | 10 + 3 |
13 |
- |
Subtraction | 10 - 3 |
7 |
* |
Multiplication | 10 * 3 |
30 |
/ |
Division | 10 / 3 |
3 (division entière) |
% |
Modulo (reste) | 10 % 3 |
1 |
Vous pouvez essayer d’exécuter ce code vous-même dans l’éditeur de code C#.
Comprendre le modulo (%)
L’opérateur % de module retourne tout ce qui reste après la division. Il est utile de vérifier si un nombre se divise uniformément :
Console.WriteLine(10 % 2); // Output: 0 (10 is even)
Console.WriteLine(11 % 2); // Output: 1 (11 is odd)
Ordre des opérations
C# suit l’ordre mathématique standard des opérations (PEMDAS) : parenthèses, multiplication/division, puis addition/soustraction. Utilisez des parenthèses pour contrôler l’ordre :
int standard = 2 + 3 * 4; // Multiplication first: 14
int forced = (2 + 3) * 4; // Parentheses first: 20
Opérateurs d’affectation composée
Un modèle courant consiste à mettre à jour une variable à l’aide de sa propre valeur, comme l’ajout à un score ou la soustraction d’un solde. C# a des opérateurs abrégés pour ceci :
int score = 50;
score = score + 10; // Standard way: score is 60
score += 10; // Shorthand: score is 70
Le même raccourci fonctionne pour d’autres opérations :
| Opérateur | Meaning | Example | Résultat (à partir de 10) |
|---|---|---|---|
+= |
Ajouter et attribuer | x += 5 |
15 |
-= |
Soustraire et assigner | x -= 5 |
5 |
*= |
Multiplier et assigner | x *= 5 |
50 |
/= |
Diviser et assigner | x /= 5 |
2 |
Opérateurs d'incrémentation et de décrémentation
Pour additionner ou soustraire 1, C# a des opérateurs encore plus courts : ++ et --.
int count = 5;
count++; // Same as count = count + 1
Console.WriteLine(count); // Output: 6
count--; // Same as count = count - 1
Console.WriteLine(count); // Output: 5
La position est importante : pré-incrément contre post-incrément
Les ++ opérateurs et les -- opérateurs se comportent différemment selon qu’ils apparaissent avant ou après la variable :
-
Post-incrément (
value++) : utilise d’abord la valeur actuelle, puis incrémente -
Pré-incrément (
++value) : incrémente d’abord, puis utilise la nouvelle valeur
int a = 5;
Console.WriteLine(a++); // Output: 5 (uses old value, then increments)
Console.WriteLine(a); // Output: 6 (a was incremented)
int b = 5;
Console.WriteLine(++b); // Output: 6 (increments first, then uses new value)
Console.WriteLine(b); // Output: 6
Les mêmes règles s’appliquent à -- (décrémentation).
Division avec entiers et décimales
Lorsque vous divisez deux entiers, C# tronque (supprime) la partie décimale :
int result = 7 / 2;
Console.WriteLine(result); // Output: 3 (not 3.5)
Pour conserver la décimale, au moins un des nombres doit être un type décimal :
decimal result = 7m / 2m;
Console.WriteLine(result); // Output: 3.5
C’est pourquoi le choix du type de données approprié est important pour vos calculs. Dans la section suivante, vous allez apprendre à convertir entre les types lorsque vous en avez besoin.