Introduction aux nombres à virgule et au type double

1. Nombres à virgule

Souviens-toi de notre projet — imaginons que c’est une calculatrice toute simple. Ou n’importe quel programme où il faut faire des calculs (ça va du calcul d’argent basique à de la physique bien plus complexe). Dans la vraie vie, tout n’est pas un nombre entier, et on n’y peut rien !

Alors, on va s’équiper d’un nouveau type de données !

En programmation, les nombres à virgule sont aussi appelés nombres réels, ou nombres à virgule flottante (floating-point). En C#, comme dans la plupart des langages, ils servent à stocker non seulement des entiers, mais aussi des valeurs « à virgule » : des trucs comme 3.14, -28.57, 2.718281828...

Les nombres réels existent en deux types principaux :

float

double

Le type float

Le type float tient son nom de floating-point number — nombre à virgule flottante. Les nombres réels, c’est des nombres mathématiques, ils ont des propriétés bien précises. Mais l’ordi, lui, il a plein de limites. Donc, ce n’est pas tout à fait correct d’appeler les nombres à virgule en C# des « réels ». On utilise plutôt le terme « nombres à virgule flottante ».

Le type float stocke en général 7 chiffres significatifs (genre 0.1234567), l’exposant de 10, et ça prend 4 octets en mémoire. C’est pas énorme pour des calculs précis, donc tout le monde est vite passé aux nombres en double précision.

2. Déclaration et initialisation de variables de type double

C’est pareil qu’avec int — sauf qu’on utilise maintenant double.

// On déclare une variable et on lui donne la valeur de Pi
double pi = 3.1415926;

// On peut déclarer sans initialiser
double averageSalary;
averageSalary = 91234.56;

// On peut faire des calculs !
double pizzaPieces = 8;
double friends = 3;
double piecesPerFriend = pizzaPieces / friends; // 2.666... (et pas 2)

Particularités de la syntaxe :

• Le séparateur décimal, c’est le point (3.14). Si tu mets une virgule, tu auras une erreur de compilation !
• En vrai, si tu écris double d = 3;, tu n’auras pas d’erreur — les types sont convertis automatiquement (l’entier devient « réel » sans perte).

3. Saisie et affichage de nombres réels avec Console

On va d’abord essayer d’afficher un nombre à virgule :

double amount = 42.75;
Console.WriteLine(amount); // Affichera : 42.75

Nickel ! Et si on ajoute du texte :

Console.WriteLine("Sur ton compte : " + amount + " euros."); // Sur ton compte : 42.75 euros.

Saisie au clavier

Le truc à savoir : Console.ReadLine() renvoie toujours une chaîne, il faut donc la convertir en double.

Console.WriteLine("Entre la température dehors :");
string input = Console.ReadLine();
double temperature = double.Parse(input); // On convertit la chaîne en double

Console.WriteLine("Dehors il fait : " + temperature + " degrés.");

4. Le type double en action : arithmétique

Toutes les opérations classiques (+, -, *, /) marchent comme pour int :

double distance = 100.5;
double time = 2.0;
double speed = distance / time; // 50.25

Console.WriteLine("Vitesse moyenne : " + speed); // Vitesse moyenne : 50.25

Voilà pour l’arithmétique. La seule différence : le résultat d’une division est toujours un nombre à virgule, si au moins un des opérandes est un double.

Comparons avec int

int a = 5, b = 2;
Console.WriteLine(a / b); // 2 (le reste est ignoré)

double aa = 5, bb = 2;
Console.WriteLine(aa / bb); // 2.5

5. Erreurs et bizarreries typiques avec double

Erreur de conversion de chaîne

Situation classique : l’utilisateur tape 3,14 — mais le programme attend 3.14.

// Ça va planter si on tape "3,14"
double value = double.Parse(Console.ReadLine());

Si tu utilises le programme dans des pays où la « virgule » est le séparateur décimal (genre Pologne, Allemagne), alors double.Parse fonctionne bien. Mais si l’appli tourne avec des paramètres « anglais », il attend un point.

Erreur de « précision » des nombres sur l’ordi

C’est là que les débutants sont souvent un peu paumés :

double x = 0.1 + 0.2;
Console.WriteLine(x); // Euh... 0.30000000000000004

Félicitations, tu viens de croiser la « magie » de la représentation des nombres à virgule dans l’ordi. En fait, beaucoup de nombres ne peuvent pas être représentés exactement en binaire. On en reparlera dans la prochaine leçon, pour l’instant — panique pas ! En général, ce n’est pas critique pour la plupart des applis, mais il y a des subtilités en finance et en sciences exactes.

6. Important : double et int — conversion automatique et explicite

Parfois, tu additionnes un entier et un nombre à virgule, ou tu assignes un int à une variable double — pas d’erreur :

int i = 2;
double d = i; // Tout roule !
Console.WriteLine(d); // 2

double dd = 3.7;
int ii = (int) dd; // Là, il faut convertir explicitement le double en int !
Console.WriteLine(ii); // 3, la partie décimale est jetée

Souvent, ça surprend — pourquoi la partie après la virgule a disparu ? Tout simplement parce que le type int ne sait pas stocker de décimales (tout ce qui est après le point, c’est perdu à jamais).

On verra plus en détail la conversion de double en int et l’opérateur (int) dans la prochaine leçon.

7. Affichage formaté : afficher joliment un double

Souvent, par défaut, un double s’affiche avec plein de zéros inutiles. On peut formater l’affichage :

double temp = 23.56789;
Console.WriteLine(temp); // 23.56789

Console.WriteLine(temp.ToString("F2")); // 23.57 (2 chiffres après la virgule)
Console.WriteLine($"{temp:F1}");        // 23.6 (interpolation de chaînes)

2

Mission

C# SELF, niveau 6, leçon 2

Bloqué

Arithmétique simple avec le type `double`

Arithmétique simple avec le type `double`

Ouvrir

2

Mission

C# SELF, niveau 6, leçon 2

Bloqué

Calcul de la vitesse

Calcul de la vitesse

Ouvrir