CodeGym /Cours /C# SELF /Nombres et caractères en C#

Nombres et caractères en C#

C# SELF
Niveau 6, Leçon 1
Disponible

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
sbyte
1 octet -128 à 127 -128, 0, 127
short
2 octets -32 768 à 32 767 -1000, 0, 32000
int
4 octets -2 147 483 648 à 2 147 483 647 -1000000, 0, 2000000
long
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
byte
1 octet 0 à 255 0, 128, 255
ushort
2 octets 0 à 65 535 1000, 65000
uint
4 octets 0 à 4 294 967 295 100, 4000000000
ulong
8 octets 0 à 18 446 744 073 709 551 615 1, 18_000_000_000_000

Types à virgule

Type Taille Exemples de valeurs Description
float
4 octets 3.14f, -0.001f précision simple (7 chiffres)
double
8 octets 3.1415, -1.7E+308 précision double (15-16 chiffres)
decimal
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;
Utilisation des soulignés pour rendre les nombres plus lisibles

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).

2
Mission
C# SELF, niveau 6, leçon 1
Bloqué
Des nombres bien sculptés
Des nombres bien sculptés
2
Mission
C# SELF, niveau 6, leçon 1
Bloqué
Tout le monde aime Unicode
Tout le monde aime Unicode
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION