1. Quels types de nombres existent ?
En prog, on bosse tout le temps avec des nombres — de l’âge d’un utilisateur au nombre d’étoiles dans la galaxie ou de centimes sur un compte bancaire. Mais chaque problème a besoin de son type de nombre : parfois il faut juste des entiers, parfois des décimales super précises, et parfois des nombres "sans moins".
Nombres entiers (int et autres)
Un entier — c’est un nombre sans partie décimale.
En C#, on utilise le plus souvent le type int, mais il y a aussi d’autres variantes qui changent en taille et en plage de valeurs.
- int — le type "boulot" principal pour les entiers. Il gère des valeurs très grandes (et très petites), et ne prend pas trop de mémoire.
Par exemple, pour compter les likes, l’âge, le nombre de jours dans l’année, on va quasi toujours utiliser int. - long — à utiliser si les valeurs peuvent être énormes (genre milliards ou trillions).
Exemple : stocker le total de vues YouTube de toute l’histoire. - short — économe, mais rarement utilisé. Pratique là où il y a plein de petites valeurs identiques (genre données audio, composantes de couleur).
- byte — pour des valeurs encore plus petites, surtout en graphisme ou gestion de fichiers, quand la mémoire compte.
Nombres à virgule (double, float, decimal)
Parfois, il faut bosser avec des nombres qui ont une partie décimale. Genre température, moyenne d’un étudiant, prix d’un article avec des centimes.
- double — c’est le type "par défaut" pour stocker des nombres à virgule. Suffisamment précis pour la plupart des calculs (exemple : 3.1415926535…).
- float — plus léger et moins précis, on le croise souvent en graphisme ou quand tu traites de gros tableaux de données et que tu veux économiser la RAM.
- decimal — fait pour les trucs financiers et la compta, quand il faut garder la précision jusqu’au centime, pour éviter les "pertes" à cause de la façon dont les nombres à virgule sont stockés. Genre pour stocker le solde d’un compte, le prix d’un article, le taux de change.
Types numériques spéciaux
En C#, il y a des types numériques en plus pour des cas particuliers :
- uint, ulong, ushort — types "non signés", ils ne prennent que des valeurs positives, mais la plage est 2x plus grande que leurs équivalents "signés".
- sbyte — petit type signé (pour stocker compact des valeurs négatives et positives de -128 à 127).
- BigInteger — si tu dois manipuler des nombres énormes, au-delà des plages standards, genre en crypto ou en calculs d’astro.
2. Nombres signés et non signés
Un type signé peut stocker des nombres positifs et négatifs. Pratique quand les valeurs peuvent être "au-dessus ou en-dessous de zéro" : genre température, solde d’un compte, altitude par rapport à la mer.
Un type non signé — que zéro et des valeurs positives. Parfait quand il ne peut pas y avoir de moins — genre nombre de personnes dans une pièce, octets dans un fichier, temps.
Exemple :
- int (signé) : -10, 0, 50
- uint (non signé) : 0, 10, 1000
En utilisant un type non signé, tu peux stocker 2x plus de valeur max dans la variable (vu qu’il n’y a pas la "moitié négative de la plage"). On les utilise quand on sait que la valeur ne sera jamais négative.
Types entiers signés
| Type | Taille | Plage de valeurs | Exemple d’utilisation |
|---|---|---|---|
|
1 octet | -128 à 127 | -128, 0, 127 |
|
2 octets | -32 768 à 32 767 | -1000, 0, 32000 |
|
4 octets | -2 147 483 648 à 2 147 483 647 | -1000000, 0, 2000000 |
|
8 octets | -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807 |
-10_000_000_000, 1 |
Types entiers non signés
| Type | Taille | Plage de valeurs | Exemple d’utilisation |
|---|---|---|---|
|
1 octet | 0 à 255 | 0, 128, 255 |
|
2 octets | 0 à 65 535 | 1000, 65000 |
|
4 octets | 0 à 4 294 967 295 | 100, 4000000000 |
|
8 octets | 0 à 18 446 744 073 709 551 615 | 1, 18_000_000_000_000 |
Types à virgule
| Type | Taille | Exemples de valeurs | Description |
|---|---|---|---|
|
4 octets | 3.14f, -0.001f | précision simple (7 chiffres) |
|
8 octets | 3.1415, -1.7E+308 | précision double (15-16 chiffres) |
|
16 octets | 0.1m, 12345.6789m | haute précision pour la finance |
3. Suffixes pour les nombres
Parfois, il faut préciser explicitement le type que tu veux pour un nombre. On fait ça avec des suffixes :
- L ou l — pour le type long (exemple : 10000000000L)
- U ou u — pour le type uint (exemple : 123U)
- F ou f — pour le type float (exemple : 3.14f)
- D ou d — pour le type double (en général pas besoin, car un nombre à virgule sans suffixe est déjà un double)
- M ou m — pour le type decimal (exemple : 99.99m — super important pour l’argent !)
Si tu ne mets pas de suffixe, par défaut un entier est un int, et un nombre à virgule est un double. Par exemple, 42 c’est un int, et 3.14 c’est un double.
Pourquoi faire ça ? Par exemple, pour éviter une erreur quand tu assignes un gros nombre à une variable de type long :
long bigNumber = 9000000000L; // si tu enlèves le L, tu auras une erreur de compilation
Et pour l’argent, utilise toujours decimal avec le suffixe m :
decimal price = 999.99m;
4. Séparateur souligné _
Quand les nombres sont longs, c’est facile de se perdre dans les zéros. Pour le style et la lisibilité, en C# tu peux utiliser des soulignés dans le nombre.
int population = 146_700_000;
long stars = 100_000_000_000L;
C’est totalement légal : le compilateur ignore les soulignés, et toi tu vois direct les groupes de chiffres. Juste, ne mets pas de souligné au début, à la fin, après un point ou avant un suffixe.
5. Type caractère char
Parfois, dans un programme, tu dois bosser non pas avec des nombres, mais avec des caractères individuels : une lettre, un chiffre, un signe, même un espace. Pour ça, il y a un type spécial — char.
C’est quoi char ?
C’est une variable qui stocke un seul caractère :
- une lettre latine ou cyrillique ('A', 'я')
- un chiffre ('5')
- un caractère spécial ('#', '%', '@')
- un caractère de contrôle ('\\n' — retour à la ligne)
À savoir :
- La valeur d’un char s’écrit entre apostrophes : char letter = 'B';
- En vrai, dans char c’est le code numérique du caractère (en Unicode), donc tu peux comparer, convertir en int et même faire de l’arithmétique simple :
char a = 'A';
char b = (char)(a + 1); // 'B'
int code = a; // 65 — code de la lettre 'A'
Tu peux utiliser des caractères spéciaux, genre : char tab = '\\t'; // caractère tabulation
Pourquoi utiliser char ?
Pour bosser sur du texte caractère par caractère (genre vérifier la première lettre d’une string, chercher une ponctuation, lire un mot de passe caractère par caractère).
GO TO FULL VERSION