Tutoriel : Utilisation d’entiers et de nombres à virgule flottante en C#

Ce tutoriel vous explique les types numériques en C#. Vous écrivez de petites quantités de code, puis vous compilez et exécutez ce code. Ce didacticiel contient une série de leçons qui explorent les nombres et les opérations mathématiques en C#. Ces leçons vous enseignent les principes fondamentaux de la langue C#.

Dans ce tutoriel, vous allez :

Lancez un espace de code GitHub avec un environnement de développement C#.
Explorez les mathématiques entières.
Découvrez l’ordre des opérations.
Découvrez les limites et la précision des entiers.
Découvrez les types à virgule flottante.
Découvrez le type décimal.

Prerequisites

Vous devez disposer de l’un des éléments suivants :

Un compte GitHub pour utiliser GitHub Codespaces. Si vous n’en avez pas encore, vous pouvez créer un compte gratuit à GitHub.com.
Un ordinateur avec les outils suivants installés :

Explorer les mathématiques entières

Pour démarrer un Espace de code GitHub avec l’environnement du didacticiel, ouvrez une fenêtre de navigateur dans le référentiel codespace du didacticiel . Sélectionnez le bouton Code vert et l’onglet Espaces de code . Sélectionnez ensuite le + signe pour créer un espace de code à l’aide de cet environnement. Si vous avez terminé le didacticiel hello world , vous pouvez ouvrir cet espace de code au lieu de en créer un nouveau.

Lorsque votre espace de code est chargé, créez un fichier dans le dossier didacticiels nommé numbers.cs.
Ouvrez votre nouveau fichier.

Tapez ou copiez le code suivant dans numbers.cs :

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

Exécutez ce code en tapant les commandes suivantes dans le terminal intégré :
```
cd ./tutorials
dotnet numbers.cs
```
Vous avez vu l’une des opérations mathématiques fondamentales avec des entiers. Le int type représente un entier, un zéro, un nombre positif ou négatif entier. Vous utilisez le symbole + pour l’ajout. Voici d’autres opérations mathématiques courantes pour les entiers :
- - 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 numbers.cs dans la fenêtre du terminal.

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. Le mélange de variables et de nombres constants est autorisé.

Conseil / Astuce

Lorsque vous explorez C# (ou n’importe quel langage de programmation), vous pouvez faire des erreurs lorsque vous écrivez du code. Le compilateur trouve ces erreurs et les signale à vous. Lorsque la sortie contient des messages d’erreur, examinez attentivement l’exemple de code et le code dans votre fenêtre pour voir ce qu’il faut corriger. Vous pouvez également demander à Copilot de trouver des différences ou de repérer des erreurs. Cet exercice vous aide à apprendre 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 appelez une méthode en écrivant le nom de la méthode suivi de (). L’organisation de votre code en méthodes facilite la prise en main 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);
}

Explorer l’ordre des opérations

Commentez l'invocation de WorkingWithIntegers(). La sortie est moins encombrée lorsque vous travaillez dans cette section :
```
//WorkWithIntegers();
```
Le // commence un commentaire en C#. Les commentaires sont n’importe quel texte que vous souhaitez conserver dans votre code source, mais pas en tant que code. Le compilateur ne génère aucun code exécutable à partir de commentaires. Étant donné qu’il WorkWithIntegers() s’agit 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 des règles cohérentes avec les règles que vous avez apprises en mathématiques. La multiplication et la division sont prioritaires sur l’addition et la soustraction. Explorez cela en ajoutant le code suivant après l’appel à WorkWithIntegers(), et en tapant dotnet numbers.cs dans la fenêtre de terminal :
```
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’ajout.
Vous pouvez forcer un ordre d’opération différent en ajoutant des parenthèses autour de l’opération ou des opérations souhaitées en premier. Ajoutez les lignes suivantes et réexécutez :
```
d = (a + b) * c;
Console.WriteLine(d);
```
Explorez-en davantage en combinant de nombreuses opérations différentes. Ajoutez quelque chose comme les lignes suivantes. Réessayez dotnet numbers dans la fenêtre de terminal.
```
d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
Console.WriteLine(d);
```
Vous remarquerez peut-être un comportement intéressant pour les entiers. La division entière produit toujours un résultat entier, même lorsque vous attendez que le résultat inclue une partie décimale ou fractionnaire.

Si vous ne voyez pas 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 numbers.cs à nouveau dans la fenêtre de terminal pour afficher les résultats.

Avant de continuer, prenons tout le code que vous avez écrit dans cette section et mettons-le dans une nouvelle méthode. Appelez 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

L’exemple précédent montre que la division entière tronque le résultat. Vous pouvez obtenir le reste à l’aide de l’opérateur de reste , le % caractère.

Essayez le code suivant après l’appel de la 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 entier C# diffère des entiers mathématiques d’une autre manière : le int type a des limites minimales et maximales. Essayez le code suivant pour voir ces 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 disposez d’une condition de sous-débit ou de dépassement de capacité . La réponse semble s’encapsuler d’une limite à l’autre. Pour voir un exemple, ajoutez ces deux lignes à votre code :
```
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). C’est le même que min + 2. L’opération d’ajout a dépassé les valeurs autorisées pour les entiers. La réponse est un 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 différentes limites et précisions que vous pouvez utiliser lorsque le int type ne répond pas à vos besoins. Examinons ensuite ces types de nombres.

Utiliser le type double

Le double type numérique représente un nombre à virgule flottante double précision. Ces termes peuvent être nouveaux pour vous. Un nombre à virgule flottante est utile pour représenter des nombres non intégraux qui peuvent être très volumineux ou petits. 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 que ceux de simple précision. Sur les ordinateurs modernes, vous utilisez plus couramment une double précision que des nombres de précision uniques. Les nombres de précision uniques sont déclarés à l’aide du float mot clé. Nous allons explorer.

Ajoutez le code suivant et consultez 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 une expression légèrement plus compliquée avec des nombres réels. Vous pouvez utiliser les valeurs suivantes ou remplacer d’autres nombres :
```
double a = 19;
double b = 23;
double c = 8;
double d = (a + b) / c;
Console.WriteLine(d);
```
La plage d’une valeur double est beaucoup plus grande que les valeurs entières. Essayez le code suivant que vous ajoutez à ce que vous avez écrit jusqu’à présent :
```
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 signe est le signe. Le nombre à droite est l’exposant, sous la forme d’une puissance de 10.
Tout comme les nombres décimaux en mathématiques, les doubles en C# peuvent avoir des erreurs d’arrondi. Essayez ce code :
```
double third = 1.0 / 3.0;
Console.WriteLine(third);
```
Vous savez que 0.3 c’est 3/10 et pas exactement le même que 1/3. De même, 0.33 c’est 33/100. Cette valeur est plus proche de 1/3, mais toujours pas exacte. Peu importe le nombre de décimales que vous ajoutez, une erreur d’arrondi persiste.

Défi

Essayez d’autres calculs avec de grands nombres, de petits nombres, de multiplication et de division à l’aide du double type. Essayez des calculs plus compliqués. Après avoir passé un certain temps avec le défi, prenez le code que vous avez écrit et placez-le 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# : entiers et doubles. Il existe un autre type à apprendre : le decimal type. Le decimal type a une plage plus petite mais plus précise que 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 inférieure au double type.

Vous pouvez voir la plus grande précision avec le type décimal en essayant 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);
```
Notez que les mathématiques avec le type décimal ont plus de chiffres à droite du point décimal.

Le M suffixe sur les nombres indique qu’une constante doit utiliser le decimal type. Sinon, le compilateur suppose le double type.

Remarque

La lettre M est la plus distincte visuellement entre les mots clés double et decimal.

Défi

Maintenant que vous connaissez les différents types numériques, écrivez du code qui calcule la zone d’un cercle dont le rayon est de 2,50 centimètres. N’oubliez pas que la zone d’un cercle est le rayon multiplié par PI. Un conseil : .NET contient une constante pour PI, Math.PI que vous pouvez utiliser pour cette valeur. Math.PI, comme toutes les constantes déclarées dans le System.Math espace de noms, 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.

Lorsque vous l’essayez, ouvrez le volet d’informations pour voir comment vous l’avez fait :

double radius = 2.50;
double area = Math.PI * radius * radius;
Console.WriteLine(area);

Essayez d’autres formules si vous le souhaitez.

Vous pouvez en savoir plus sur les nombres en C# dans les articles suivants :

Nettoyer les ressources

GitHub supprime automatiquement votre Espace de code après 30 jours d’inactivité. Si vous envisagez d’explorer d’autres tutoriels de cette série, vous pouvez laisser votre espace de code provisionné. Si vous êtes prêt à visiter le site .NET pour télécharger le Kit de développement logiciel (SDK) .NET, vous pouvez supprimer votre espace de code. Pour supprimer votre espace de code, ouvrez une fenêtre de navigateur et accédez à vos espaces de code. Vous devez voir une liste de vos espaces de code dans la fenêtre. Sélectionnez les trois points (...) dans l’entrée de l’espace de code du didacticiel Learn, puis sélectionnez Supprimer.

Étape suivante

Tuples et types

Commentaires

Est-ce que cette page vous a été utile?

Last updated on 2025-12-11