Exercice - Effectuer des opérations mathématiques

  • 10 minutes

Maintenant que vous avez compris les bases de l’addition et, plus important, la conversion de type implicite entre les types de données numériques et de chaîne, nous allons nous intéresser à plusieurs autres opérations mathématiques courantes sur les données numériques.

Effectuer des opérations mathématiques simples

Écrire du code pour faire des additions, des soustractions, des multiplications et des divisions avec des entiers

  1. Sélectionnez tout le code dans l’éditeur .NET, puis appuyez sur Supprimer ou Retour arrière pour le supprimer.

  2. Entrez le code suivant dans l’Éditeur .NET :

    int sum = 7 + 5;
int difference = 7 - 5;
int product = 7 * 5;
int quotient = 7 / 5;

Console.WriteLine("Sum: " + sum);
Console.WriteLine("Difference: " + difference);
Console.WriteLine("Product: " + product);
Console.WriteLine("Quotient: " + quotient);

  3. Exécutez le code. Vous devez normalement voir la sortie suivante :

    Sum: 12
Difference: 2
Product: 35
Quotient: 1

Comme vous pouvez le voir :

  • + est l’opérateur d’addition
  • - est l’opérateur de soustraction
  • * est l’opérateur de multiplication
  • / est l’opérateur de division

Toutefois, le quotient résultant de l’exemple de division ne correspond peut-être pas à ce que vous attendiez. Les valeurs après la décimale sont tronquées à partir de quotient car celui-ci est défini comme int, et int ne peut pas contenir de valeurs après la décimale.

Ajouter du code pour faire une division en utilisant des données décimales littérales

Pour que la division fonctionne, vous devez utiliser un type de données qui prend en charge les chiffres décimaux après la virgule décimale comme decimal.

  1. Supprimez le code des étapes précédentes et entrez le code suivant dans l’éditeur .NET :

    decimal decimalQuotient = 7.0m / 5;
Console.WriteLine($"Decimal quotient: {decimalQuotient}");

  2. Exécutez le code. Vous devez normalement voir la sortie suivante :

    Decimal quotient: 1.4

Pour que cela fonctionne, le quotient (à gauche de l’opérateur d’assignation) doit être de type decimal et au moins un des nombres divisés doit également être de type decimal (les deux nombres peuvent également être de type decimal).

Voici deux exemples supplémentaires qui fonctionnent tout aussi bien :

decimal decimalQuotient = 7 / 5.0m;
decimal decimalQuotient = 7.0m / 5.0m;

Par contre, les lignes de code suivantes ne fonctionnent pas (ou donnent des résultats inexacts) :

int decimalQuotient = 7 / 5.0m;
int decimalQuotient = 7.0m / 5;
int decimalQuotient = 7.0m / 5.0m;
decimal decimalQuotient = 7 / 5;

Ajouter du code pour caster les résultats de la division entière

Et si vous n’utilisez pas de valeurs littérales ? En d’autres termes, que se passe-t-il si vous devez diviser deux variables de type int, mais que vous ne voulez pas un résultat tronqué ? Dans ce cas, vous devez effectuer un cast de type de données int en decimal. Le cast est un type de conversion de données qui indique au compilateur de traiter temporairement une valeur comme si elle était un autre type de données.

Pour caster int en decimal, ajoutez l’opérateur de cast avant la valeur. Vous utilisez le nom du type de données entre parenthèses devant la valeur pour le caster. Ici, vous ajoutez (decimal) avant les variables first et second.

  1. Supprimez le code des étapes précédentes et entrez le code suivant dans l’éditeur .NET :

    int first = 7;
int second = 5;
decimal quotient = (decimal)first / (decimal)second;
Console.WriteLine(quotient);

  2. Exécutez le code. Vous devez normalement voir la sortie suivante :

    1.4

Notes

Vous avez vu trois usages pour l’opérateur de parenthèses : appel de méthode, ordre des opérations et cast.

Écrire du code pour déterminer le reste après une division d’entiers

L’opérateur modulo % vous donne le reste d’une division int. Ce que vous voulez vraiment savoir ici, c’est si un nombre est divisible par un autre. Cela peut être utile pour des opérations longues quand une boucle est effectuée sur des centaines ou des milliers d’enregistrements de données et que vous voulez fournir un feedback à l’utilisateur final tous les 100 enregistrement de données traités.

  1. Supprimez le code des étapes précédentes et entrez le code suivant dans l’éditeur .NET :

    Console.WriteLine($"Modulus of 200 / 5 : {200 % 5}");
Console.WriteLine($"Modulus of 7 / 5 : {7 % 5}");

  2. Exécutez le code. Vous devez normalement voir la sortie suivante :

    Modulus of 200 / 5 : 0
Modulus of 7 / 5 : 2

Lorsque le modulo a la valeur 0, cela signifie que le dividende est divisible par le diviseur.

Ordre des opérations

Comme vous l’avez appris dans l’exercice précédent, vous pouvez utiliser les symboles () comme opérateurs de l’ordre des opérations. Toutefois, ce n’est pas la seule façon de déterminer l’ordre des opérations.

En math, PEMDAS est un acronyme qui aide les étudiants à mémoriser l’ordre des opérations. L’ordre est le suivant :

  1. Parenthèses (tout ce qui est entre parenthèses est exécuté en premier)
  2. Exposants
  3. Multiplication et Division (de gauche à droite)
  4. Addition et Soustraction (de gauche à droite)

C# suit le même ordre que PEMDAS, sauf pour les exposants. Bien qu’il n’existe pas d’opérateur d’exposant en C#, vous pouvez utiliser la méthode System.Math.Pow. Le module « Appeler des méthodes de la bibliothèque de classes .NET avec C# » présente cette méthode et d’autres.

Écrire du code pour appliquer l’ordre des opérations de C#

  1. Supprimez le code des étapes précédentes et entrez le code suivant dans l’éditeur .NET :

    int value1 = 3 + 4 * 5;
int value2 = (3 + 4) * 5;
Console.WriteLine(value1);
Console.WriteLine(value2);

    Ici, vous voyez la différence quand vous faites les mêmes opérations dans un ordre différent.

  2. Exécutez le code. Vous devez normalement voir la sortie suivante :

    23
35

Récapitulatif

Voici ce que vous avez appris jusqu’à présent concernant les opérations mathématiques en C# :

  • Utilisez des opérateurs comme +, -, * et / pour effectuer des opérations mathématiques simples.
  • La division de deux valeurs int entraîne la troncation des valeurs après la virgule décimale. Pour conserver les valeurs après la virgule décimale, vous devez d’abord caster le diviseur ou le dividende (ou les deux) de int en un nombre à virgule flottante comme decimal, puis le quotient doit être du même type à virgule flottante afin d’éviter la troncation.
  • Effectuez une opération de cast pour traiter temporairement une valeur comme si elle était d’un type de données différent.
  • Utilisez l’opérateur % pour capturer le reste après la division.
  • L’ordre des opérations suit les règles de l’acronyme PEMDAS.