Comment utiliser des nombres entiers et à virgule flottante en langage C#

Article
05/10/2023

Ce tutoriel permet de découvrir les types numériques en C#. Vous allez écrire de petites quantités de code, puis vous compilerez et exécuterez ce code. Ce tutoriel comporte une série de leçons visant à explorer les nombres et les opérations mathématiques en C#. Ces leçons présentent les concepts de base du langage C#.

Conseil

Pour coller un extrait de code dans le mode focus, vous devez utiliser le raccourci clavier (Ctrl + v ou cmd + v).

Prérequis

Le tutoriel suppose que vous avez un ordinateur configuré pour le développement local. Consultez Configurer votre environnement local pour obtenir des instructions sur l’installation et une vue d’ensemble du développement d’applications dans .NET.

Si vous ne souhaitez pas configurer un environnement local, consultez la version interactive dans le navigateur de ce tutoriel.

Explorer les mathématiques avec des entiers

Créez un répertoire nommé numbers-quickstart. Définissez le répertoire actif et exécutez la commande suivante :

dotnet new console -n NumbersInCSharp -o .

Important

Les modèles C# pour .NET 6 utilisent des instructions de niveau supérieur. Votre application ne correspond peut-être pas au code de cet article, si vous avez déjà effectué une mise à niveau vers .NET 6. Pour plus d’informations, consultez l’article Les nouveaux modèles C# génèrent des instructions de niveau supérieur.

Le SDK .NET 6 ajoute également un ensemble de directives implicitesglobal using pour les projets qui utilisent les kits SDK suivants :

Microsoft.NET.Sdk
Microsoft.NET.Sdk.Web
Microsoft.NET.Sdk.Worker

Ces directives implicites global using incluent les espaces de noms les plus courants pour le type de projet.

Pour plus d’informations, consultez l’article sur les directives d’utilisation implicite

Ouvrez Program.cs dans votre éditeur favori et remplacez le contenu du fichier par le code suivant :

int a = 18;
int b = 6;
int c = a + b;
Console.WriteLine(c);

Exécutez ce code en tapant dotnet run dans votre fenêtre de commande.

Vous avez vu l’une des opérations mathématiques fondamentales avec des nombres entiers. Le type int représente un nombre entier, un zéro, ou un nombre positif ou négatif entier. Vous utilisez le symbole + pour effectuer une addition. Les autres opérations mathématiques courantes avec des entiers sont les suivantes :

- pour la soustraction
* pour la multiplication
/ pour la division

Commencez par explorer ces différentes opérations. Ajoutez ces lignes après la ligne qui écrit la valeur de c :

// subtraction
c = a - b;
Console.WriteLine(c);

// multiplication
c = a * b;
Console.WriteLine(c);

// division
c = a / b;
Console.WriteLine(c);

Exécutez ce code en tapant dotnet run dans votre fenêtre de commande.

Vous pouvez également expérimenter en écrivant plusieurs opérations mathématiques dans la même ligne si vous le souhaitez. Essayez c = a + b - 12 * 17; par exemple. La combinaison de variables et de nombres constants est autorisée.

Conseil

Durant votre exploration de C# (ou de tout autre langage de programmation), vous commettrez des erreurs d’écriture du code. Le compilateur détectera ces erreurs et vous les signalera. Si la sortie contient des messages d’erreur, vérifiez attentivement l’exemple de code ainsi que le code dans votre fenêtre pour identifier les corrections à apporter. Cet exercice vous aidera à mieux comprendre la structure du code C#.

Vous avez terminé la première étape. Avant de commencer la section suivante, nous allons déplacer le code actuel dans une méthode distincte. Une méthode est une série d’instructions regroupées et nommées. Vous nommez une méthode en écrivant le nom de la méthode suivi de (). L’organisation de votre code en méthodes facilite l’utilisation d’un nouvel exemple. Lorsque vous avez terminé, votre code doit ressembler à ceci :

WorkWithIntegers();

void WorkWithIntegers()
{
    int a = 18;
    int b = 6;
    int c = a + b;
    Console.WriteLine(c);


    // subtraction
    c = a - b;
    Console.WriteLine(c);

    // multiplication
    c = a * b;
    Console.WriteLine(c);

    // division
    c = a / b;
    Console.WriteLine(c);
}

La ligne WorkWithIntegers(); appelle la méthode. Le code suivant déclare la méthode et la définit.

Explorer l’ordre des opérations

Commentez l’appel à WorkingWithIntegers(). La sortie est ainsi moins encombrée lorsque vous travaillez dans cette section :

//WorkWithIntegers();

// démarre un commentaire dans C#. Les commentaires correspondent à du texte que vous voulez conserver dans votre code source sans l’exécuter en tant que code. Le compilateur ne génère aucun code exécutable à partir des commentaires. Étant donné que WorkWithIntegers() est d’une méthode, vous devez uniquement commenter une seule ligne.

Le langage C# définit la priorité des différentes opérations mathématiques avec à l’aide de règles cohérentes avec les règles mathématiques que vous avez apprises. La multiplication et la division ont priorité sur l’addition et la soustraction. Explorez cela en ajoutant le code suivant après l’appel et WorkWithIntegers()en exécutant dotnet run:

int a = 5;
int b = 4;
int c = 2;
int d = a + b * c;
Console.WriteLine(d);

La sortie montre que la multiplication est effectuée avant l’addition.

Vous pouvez appliquer un ordre de calcul différent en mettant entre parenthèses la ou les opérations à exécuter en premier. Ajoutez les lignes suivantes et exécutez à nouveau :

d = (a + b) * c;
Console.WriteLine(d);

Pratiquez en combinant plusieurs opérations différentes. Ajoutez quelque chose comme les lignes suivantes. Essayez dotnet run à nouveau.

d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
Console.WriteLine(d);

Vous avez peut-être observé un comportement intéressant des entiers. La division d’entiers produit toujours un résultat entier, même quand vous pensez que le résultat devrait inclure une partie décimale ou fractionnaire.

Si vous n’avez pas vu ce comportement, essayez le code suivant :

int e = 7;
int f = 4;
int g = 3;
int h = (e + f) / g;
Console.WriteLine(h);

Tapez dotnet run à nouveau pour afficher les résultats.

Avant de continuer, prenez tout le code que vous avez écrit dans cette section et placez-le dans une nouvelle méthode. Nommez cette nouvelle méthode OrderPrecedence. Votre code doit ressembler à ceci :

// WorkWithIntegers();
OrderPrecedence();

void WorkWithIntegers()
{
    int a = 18;
    int b = 6;
    int c = a + b;
    Console.WriteLine(c);


    // subtraction
    c = a - b;
    Console.WriteLine(c);

    // multiplication
    c = a * b;
    Console.WriteLine(c);

    // division
    c = a / b;
    Console.WriteLine(c);
}

void OrderPrecedence()
{
    int a = 5;
    int b = 4;
    int c = 2;
    int d = a + b * c;
    Console.WriteLine(d);

    d = (a + b) * c;
    Console.WriteLine(d);

    d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
    Console.WriteLine(d);

    int e = 7;
    int f = 4;
    int g = 3;
    int h = (e + f) / g;
    Console.WriteLine(h);
}

Explorer la précision et les limites des entiers

Ce dernier exemple a montré que la division d’entiers tronque le résultat. Vous pouvez obtenir le reste à l’aide de l’opérateur modulo, à savoir le caractère %. Essayez le code suivant après l’appel de méthode à OrderPrecedence():

int a = 7;
int b = 4;
int c = 3;
int d = (a + b) / c;
int e = (a + b) % c;
Console.WriteLine($"quotient: {d}");
Console.WriteLine($"remainder: {e}");

Le type d’entier C# diffère des entiers mathématiques d’une autre manière : le type int a des limites minimale et maximale. Ajoutez ce code pour observer les limites :

int max = int.MaxValue;
int min = int.MinValue;
Console.WriteLine($"The range of integers is {min} to {max}");

Si un calcul produit une valeur qui dépasse ces limites, vous obtenez une condition de dépassement négatif ou dépassement positif. La réponse affichée indique la plage (d’une limite à l’autre). Ajoutez ces deux lignes pour voir un exemple :

int what = max + 3;
Console.WriteLine($"An example of overflow: {what}");

Notez que la réponse est très proche de l’entier minimal (négatif). Il en est de même pour min + 2. L’addition a produit un dépassement négatif des valeurs autorisées pour les entiers. La réponse est un très grand nombre négatif, car un dépassement négatif « inclut » de la plus grande valeur d’entier possible à la plus petite.

Il existe d’autres types numériques avec une précision et des limites différentes que vous pouvez utiliser quand le type int ne répond pas à vos besoins. Examinons ensuite ces autres types. Avant de commencer la section suivante, déplacez le code que vous avez écrit dans cette section dans une méthode distincte. Nommez-le TestLimits.

Utiliser le type double

Le type numérique double représente un nombre à virgule flottante double précision. Ces termes vous sont peut-être inconnus. Un nombre à virgule flottante est utile pour représenter de très grands ou petits nombres non intégraux. Double précision est un terme relatif qui décrit le nombre de chiffres binaires utilisés pour stocker la valeur. Les nombres de double précision ont deux fois le nombre de chiffres binaires d’une simple précision. Sur les ordinateurs modernes, il est plus courant d’utiliser une double précision que des nombres de simple précision. Les nombres de simple précision sont déclarés à l’aide du mot clé float. Explorons ce type double. Ajoutez le code suivant et affichez le résultat :

double a = 5;
double b = 4;
double c = 2;
double d = (a + b) / c;
Console.WriteLine(d);

Notez que la réponse inclut la partie décimale du quotient. Essayez avec une expression légèrement plus complexe utilisant des doubles :

double e = 19;
double f = 23;
double g = 8;
double h = (e + f) / g;
Console.WriteLine(h);

La plage d’une valeur double est nettement supérieure à celle de valeurs entières. Essayez le code suivant sous ce que vous avez écrit jusque-là :

double max = double.MaxValue;
double min = double.MinValue;
Console.WriteLine($"The range of double is {min} to {max}");

Ces valeurs sont imprimées en notation scientifique. Le nombre à gauche du E est le nombre significatif. Le nombre à droite est l’exposant, en puissance de 10. Tout comme les nombres décimaux en mathématiques, les doubles en C# peuvent présenter des erreurs d’arrondi. Exécutez le code suivant :

double third = 1.0 / 3.0;
Console.WriteLine(third);

Vous savez que 0.3 le nombre fini répété de fois n’est pas exactement la même chose que 1/3.

Problème

Effectuez d’autres calculs avec des grands nombres, des petits nombres, des multiplications et des divisions à l’aide du type double. Effectuez des calculs plus complexes. Après avoir consacré plus de temps au test, placez le code que vous avez écrit dans une nouvelle méthode. Nommez cette nouvelle méthode WorkWithDoubles.

Utiliser des types décimaux

Vous avez vu les types numériques de base en C#, à savoir les entiers et les doubles. Il existe un autre type à apprendre : le type decimal. Le type decimal a une plage plus petite, mais une précision supérieure à celle du type double. Voyons voir :

decimal min = decimal.MinValue;
decimal max = decimal.MaxValue;
Console.WriteLine($"The range of the decimal type is {min} to {max}");

Notez que la plage est plus petite que celle du type double. Vous pouvez observer la plus haute précision du type décimal en exécutant le code suivant :

double a = 1.0;
double b = 3.0;
Console.WriteLine(a / b);

decimal c = 1.0M;
decimal d = 3.0M;
Console.WriteLine(c / d);

Le suffixe M des nombres permet d’indiquer comment une constante doit utiliser le type decimal. Sinon, le compilateur utilise le type double.

Notes

La lettre M a été choisie comme lettre la plus distincte visuellement entre les mots clés et les mots clés double et decimal.

Notez que le calcul utilisant le type décimal a plus de chiffres à droite de la virgule décimale.

Problème

Maintenant que vous avez vu les différents types numériques, écrivez du code qui calcule la surface d’un cercle avec un rayon de 2,5 centimètres. Rappelez-vous que la surface d’un cercle est le rayon au carré multiplié par PI. Conseil : .NET contient une constante pour PI, à savoir Math.PI, que vous pouvez utiliser pour cette valeur. Math.PI, comme toutes les constantes déclarées dans l’espace de noms System.Math, est une valeur double. Pour cette raison, vous devez utiliser double au lieu de decimal valeurs pour ce défi.

Vous devriez obtenir une réponse comprise entre 19 et 20. Vous pouvez vérifier votre réponse en consultant l’exemple de code terminé sur GitHub.

Si vous le voulez, essayez d’autres formules.

Vous avez terminé le guide de démarrage rapide « Nombres en C# ». Vous pouvez passer au guide de démarrage rapide Branches et boucles dans votre propre environnement de développement.

Pour plus d’informations sur les nombres en C#, consultez les article suivants :