CodeGym /Cours /C# SELF /Conversion explicite et implicite des types

Conversion explicite et implicite des types

C# SELF
Niveau 6, Leçon 5
Disponible

1. Introduction

T’as déjà essayé de faire rentrer une pastèque dans une bouteille ? Bah, C# se retrouve avec le même genre de galère à chaque fois que tu lui demandes d’assigner une variable d’un type à un autre. Parfois c’est easy (mettre un petit nombre dans un plus grand — genre une pomme dans une valise), et parfois faut faire gaffe (pastèque dans une bouteille — là, c’est pas sans souci).

Conversion de type — c’est l’opération qui permet de transformer une valeur d’un type de données à un autre. Tu vas souvent en avoir besoin quand tu veux additionner ou comparer des valeurs de types différents, ou les passer à des méthodes qui acceptent seulement un type précis.

Dans la vraie vie, les devs tombent là-dessus tout le temps : tu fais un paiement, tu calcules des remises, tu fais des calculs physiques ou, par exemple, tu parses des nombres tapés par l’utilisateur au clavier (là, tout arrive en string).

2. Conversion implicite des types (Implicit Conversion)

C’est quoi ça ?

La conversion implicite — c’est quand C# décide tout seul que tu peux « transférer » les données d’un type à un autre sans souci. Tout se fait automatiquement — t’écris rien de spécial, tu utilises juste les valeurs.

  • Le compilateur ne râle pas.
  • Pas besoin de commandes spéciales ou de casts.
  • Pas de perte de données (enfin, presque jamais).

Exemple de conversion implicite

int a = 42;
double b = a; // Conversion implicite int -> double

Console.WriteLine(b); // 42 (mais c’est déjà 42.0)

Ici, a du type int devient automatiquement double quand tu l’assignes à la variable b. Pas de perte de données, vu que toutes les valeurs int rentrent easy dans un double.

Ici, a du type int devient automatiquement double quand tu l’assignes à la variable b. Pas de perte de données, vu que toutes les valeurs int rentrent easy dans un double.

Quand ça marche ?

  • Quand le type de destination est plus large que le type source — il supporte une plage de données plus grande.
  • Pas de perte de données.
  • Exemples :
    • int → long
    • int → float / double
    • float → double
    • char → int

Encore un exemple :

byte x = 100;
int y = x; // byte -> int (toutes les valeurs byte rentrent dans la plage de int)

Tableau des conversions implicites pour les types numériques

From To
byte
short, ushort, int, uint, long, ulong, float, double, decimal
int
long, float, double, decimal
float
double
char
ushort, int, uint, long, ulong, float, double, decimal

3. Conversion explicite des types (Explicit Conversion, Type Cast)

Quand la magie ne suffit pas ?

Parfois, le compilateur ne peut pas garantir que la conversion sera safe, et il te demande de prendre tes responsabilités — de dire explicitement que tu sais ce que tu fais.

  • Tu risques de perdre des données.
  • Le format de la valeur peut changer.
  • Parfois la conversion est carrément impossible — tu prends une erreur.

Comment écrire une conversion explicite ?

On utilise la syntaxe avec parenthèses (cast) :

double pi = 3.1415;
int wholePi = (int)pi; // Conversion explicite double -> int

Console.WriteLine(wholePi); // 3 (la partie décimale est jetée !)

Quand on l’utilise ?

  • Quand le type de destination est plus étroit que le type source — la plage de valeurs du destinataire est plus petite que celle de la source.
  • Possible perte de la partie décimale, de données, overflow.
  • Exemples :
    • double → int
    • long → int
    • int → byte
    • Presque tous les passages entre types incompatibles.

4. On regarde les exemples

1) On perd des données ? On vérifie !

Conversion implicite — tout roule !

int small = 25;
long big = small; // Conversion implicite (int -> long)
Console.WriteLine(big); // 25

Conversion explicite — zone dangereuse !

int big = 1000;
byte small = (byte)big; // Conversion explicite (int -> byte)

Console.WriteLine(small); // 232 (!), parce que 1000 ne rentre pas dans byte (0..255)

Remarque :

Ici le résultat — « magique » 232, parce que 1000 % 256 == 232.

2) Avec les nombres à virgule flottante (double, float)

double number = 9.99;
int approximate = (int)number; // la partie décimale est juste jetée

Console.WriteLine(approximate); // 9

3) Conversion entre entiers et réels (double ↔ int)

int apples = 5;
double exactApples = apples; // int -> double (implicite)
Console.WriteLine(exactApples); // 5.0

double bananaWeight = 2.77;
int weightForReport = (int)bananaWeight; // double -> int (explicite)
Console.WriteLine(weightForReport); // 2

5. Que faire avec la conversion de chaînes : Parse et Convert

La conversion de type ne marche pas entre nombres et chaînes ! Là, il faut des méthodes spéciales, par exemple :

string strNumber = "123";
int num = int.Parse(strNumber); // ou Convert.ToInt32(strNumber);

Mais l’inverse (int → string) se fait automatiquement quand tu concatènes des chaînes :

int number = 42;
string message = "Réponse : " + number; // Conversion implicite int → string

6. Erreurs lors de la conversion des types

Leçon d’histoire : un jour, quelqu’un a oublié de faire une conversion explicite, et le paiement final s’est retrouvé 250 fois plus petit que prévu... Les étudiants, soyez attentifs !

Erreur fréquente : essayer de convertir implicitement un type où il peut y avoir une perte de données.

int big = 500;
byte small = big; // Compilateur : "Impossible ! Risque de perte de données !"

Ici, il faudra une conversion explicite :

byte small = (byte)big; // Mais tu risques de perdre des données !

Autre bug classique — t’as oublié la partie décimale :

double x = 2.9;
int y = (int)x; // y == 2, la partie décimale a disparu

Pour arrondir selon les règles mathématiques, utilise Math.Round :

int y = (int)Math.Round(x); // y == 3

7. Pièges de la conversion

  • Perte de données. Vérifie toujours si la valeur ne dépasse pas la plage autorisée du type. Par exemple, int va de -2 147 483 648 à 2 147 483 647, et byte — seulement 0–255.
  • Arrondi. Une conversion classique ((int)x) jette juste la partie décimale. Pour arrondir correctement, utilise Math.Round, Math.Floor, Math.Ceiling.
  • Littéraux numériques. Fais gaffe, écrire 3 / 2 donne 1 (division entière), alors que 3.0 / 2 — ça donne 1.5 (double) !
  • Opérations de types mixtes. Si tu mélanges, par exemple, int et double dans une expression, le résultat sera du type double.
2
Mission
C# SELF, niveau 6, leçon 5
Bloqué
Arrondir un nombre à virgule flottante à un entier
Arrondir un nombre à virgule flottante à un entier
2
Mission
C# SELF, niveau 6, leçon 5
Bloqué
Conversion d'un nombre avec perte de données
Conversion d'un nombre avec perte de données
1
Étude/Quiz
Nombres à virgule flottante, niveau 6, leçon 5
Indisponible
Nombres à virgule flottante
Problèmes de précision et valeurs spéciales
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION