C# Academy · Leçon

Conversions implicites et explicites

Convertissez des types compatibles en toute sécurité.

Conversions implicites et explicites est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Convertir entre les types

C# peut convertir un type numérique en un autre. Certaines conversions se font automatiquement (implicites), tandis que d’autres nécessitent une conversion explicite.

using System;

class Program
{
    static void Main()
    {
        int i = 10;
        double d = i;       // implicit
        int back = (int)d;   // explicit
        Console.WriteLine(d + ", " + back);
    }
}

Conversions implicites (élargissantes)

Une conversion implicite est autorisée lorsqu’aucune donnée ne peut être perdue, par exemple de int vers long ou de int vers double. Aucune conversion explicite n’est nécessaire.

using System;

class Program
{
    static void Main()
    {
        int i = 42;
        long l = i;      // widening, safe
        double d = i;    // widening, safe
        Console.WriteLine(l + ", " + d);
    }
}

Pourquoi l’élargissement est sûr

Le type cible peut représenter toutes les valeurs du type source ; le compilateur l’autorise donc silencieusement.

using System;

class Program
{
    static void Main()
    {
        byte b = 200;
        int i = b;       // byte fits in int
        Console.WriteLine("byte " + b + " -> int " + i);
    }
}

Conversions explicites (réductrices)

Une conversion explicite est nécessaire lorsque des données peuvent être perdues, par exemple de double vers int. Vous écrivez (int)value.

using System;

class Program
{
    static void Main()
    {
        double d = 9.78;
        int i = (int)d;   // truncates toward zero -> 9
        Console.WriteLine(i);
    }
}

La conversion tronque, elle n’arrondit pas

Convertir une valeur à virgule flottante en entier supprime sa partie fractionnaire ; cela ne l’arrondit pas. Utilisez d’abord Math.Round si vous voulez arrondir.

using System;

class Program
{
    static void Main()
    {
        double d = 7.99;
        Console.WriteLine("Cast: " + (int)d);
        Console.WriteLine("Round: " + (int)Math.Round(d));
    }
}

Dépassement lors d’une réduction

Si une valeur ne tient pas dans le type cible, une conversion explicite simple peut provoquer silencieusement un retour cyclique. Utilisez checked pour déclencher une erreur en cas de dépassement.

using System;

class Program
{
    static void Main()
    {
        int big = 300;
        byte wrapped = (byte)big;   // 300 wraps to 44
        Console.WriteLine("Wrapped: " + wrapped);

        try
        {
            byte safe = checked((byte)big);
            Console.WriteLine(safe);
        }
        catch (OverflowException)
        {
            Console.WriteLine("checked caught overflow");
        }
    }
}

Perte de précision

Même certaines conversions élargissantes, comme celle d’un très grand long vers float, peuvent faire perdre de la précision, bien qu’elles restent implicites.

using System;

class Program
{
    static void Main()
    {
        long big = 9007199254740993L;
        double approx = big;   // implicit, may lose precision
        Console.WriteLine("long: " + big);
        Console.WriteLine("double: " + approx.ToString("F0"));
    }
}

Conversions entre char et nombres

Un char est implicitement converti en son code numérique, et vous pouvez convertir explicitement un nombre en char.

using System;

class Program
{
    static void Main()
    {
        char c = 'A';
        int code = c;          // implicit -> 65
        char next = (char)(code + 1);   // explicit -> B
        Console.WriteLine(code + " -> " + next);
    }
}

Conversions dans les expressions

Dans une opération arithmétique mixte, les types plus petits sont automatiquement convertis vers le type plus grand avant l’opération.

using System;

class Program
{
    static void Main()
    {
        int a = 7;
        double b = 2;
        double result = a / b;   // a promoted to double -> 3.5
        Console.WriteLine(result);
    }
}

Piège de la division entière

Si les deux opérandes sont des entiers, la division est une division entière. Convertissez d’abord l’un d’eux en double pour obtenir un résultat fractionnaire.

using System;

class Program
{
    static void Main()
    {
        int a = 7, b = 2;
        Console.WriteLine("int / int: " + (a / b));
        Console.WriteLine("with cast: " + ((double)a / b));
    }
}

Mise en pratique

Privilégiez les conversions implicites lorsqu’elles sont sûres, utilisez des conversions explicites lors d’une réduction et surveillez la troncature, les dépassements et la division entière.

using System;

class Program
{
    static void Main()
    {
        int total = 17, count = 5;
        double average = (double)total / count;   // cast to avoid integer division
        int rounded = (int)Math.Round(average);
        Console.WriteLine("avg=" + average + ", rounded=" + rounded);
    }
}

Vérification rapide

Vérifiez votre compréhension des conversions.

Récapitulatif

Les conversions implicites (élargissantes) se font automatiquement lorsqu’aucune donnée n’est perdue (int vers long, int vers double). Les conversions explicites (réductrices) nécessitent une conversion comme (int)x et peuvent tronquer la valeur ou provoquer un dépassement. Utilisez checked pour détecter les dépassements et convertissez en double pour éviter la division entière.

using System;

class Program
{
    static void Main()
    {
        double d = 3.9;
        int i = (int)d;     // explicit, truncates to 3
        long l = i;          // implicit widening
        Console.WriteLine(i + ", " + l);
    }
}

Questions Fréquemment Posées

La leçon « Conversions implicites et explicites » est-elle gratuite ?

Oui — le texte complet de « Conversions implicites et explicites » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Conversions implicites et explicites » ?

Convertissez des types compatibles en toute sécurité. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Conversions implicites et explicites » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C# Academy