C# Academy · Leçon

Types valeur et types référence

Observez comment chacun est stocké et copié.

Types valeur et types référence est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Deux familles de types

Les types C# se divisent en types valeur (int, double, bool, structures) et types référence (classes, chaînes, tableaux). Ils diffèrent par leur manière d'être stockés et copiés.

using System;

class Program
{
    static void Main()
    {
        int valueType = 5;          // value type
        int[] referenceType = { 1, 2, 3 };  // reference type
        Console.WriteLine(valueType + ", length " + referenceType.Length);
    }
}

Les types valeur contiennent les données

Une variable de type valeur contient directement ses données. En général, celles-ci résident sur la pile ou directement dans l'objet qui les contient.

using System;

class Program
{
    static void Main()
    {
        int a = 10;
        double b = 3.14;
        bool c = true;
        Console.WriteLine(a + ", " + b + ", " + c);
    }
}

Les types référence contiennent une adresse

Une variable de type référence contient une référence (une adresse) vers des données stockées dans le tas. La variable et l'objet sont distincts.

using System;

class Box { public int Value; }

class Program
{
    static void Main()
    {
        Box b = new Box();   // b refers to a heap object
        b.Value = 42;
        Console.WriteLine(b.Value);
    }
}

Sémantique de copie : types valeur

Affecter un type valeur copie les données. Modifier la copie n'affecte jamais l'original.

using System;

class Program
{
    static void Main()
    {
        int a = 1;
        int b = a;   // copy
        b = 99;
        Console.WriteLine("a=" + a + ", b=" + b);
    }
}

Sémantique de copie : types référence

L’affectation d’un type référence copie la référence, et non l’objet. Les deux variables pointent alors vers le même objet.

using System;

class Box { public int Value; }

class Program
{
    static void Main()
    {
        Box a = new Box { Value = 1 };
        Box b = a;   // same object
        b.Value = 99;
        Console.WriteLine("a.Value=" + a.Value + ", b.Value=" + b.Value);
    }
}

Les structures sont des types valeur

Une struct que vous définissez est un type valeur : elle est donc copiée lors de l’affectation, tout comme int.

using System;

struct Point { public int X, Y; }

class Program
{
    static void Main()
    {
        Point p1 = new Point { X = 1, Y = 2 };
        Point p2 = p1;   // full copy
        p2.X = 99;
        Console.WriteLine("p1.X=" + p1.X + ", p2.X=" + p2.X);
    }
}

Passage aux méthodes

Par défaut, les types valeur sont passés par copie, tandis que les types référence transmettent une copie de la référence. Une méthode peut donc modifier un objet de classe que l’appelant voit, mais pas un simple entier.

using System;

class Counter { public int N; }

class Program
{
    static void BumpInt(int x) { x++; }
    static void BumpObj(Counter c) { c.N++; }

    static void Main()
    {
        int i = 0;
        BumpInt(i);
        var c = new Counter();
        BumpObj(c);
        Console.WriteLine("i=" + i + ", c.N=" + c.N);
    }
}

null et les types référence

Seuls les types référence peuvent être null (c’est-à-dire l’absence d’un objet). Les types valeur contiennent toujours une valeur, sauf s’ils sont déclarés comme pouvant être nuls avec ?.

using System;

class Program
{
    static void Main()
    {
        string text = null;        // reference type can be null
        int? maybe = null;          // nullable value type
        Console.WriteLine((text == null) + ", " + (maybe == null));
    }
}

Différences d’égalité

Pour les types valeur, == compare les données. Pour les types référence, == compare généralement l’identité (le même objet), sauf si ce comportement est redéfini.

using System;

class Program
{
    static void Main()
    {
        int a = 5, b = 5;
        Console.WriteLine("ints: " + (a == b));   // True - same value

        object o1 = new object();
        object o2 = new object();
        Console.WriteLine("objects: " + (o1 == o2));   // False - different identity
    }
}

Valeurs par défaut

Les types valeur ont une valeur par défaut proche de zéro (0, faux) ; les types référence ont par défaut la valeur null.

using System;

class Program
{
    static void Main()
    {
        int defaultInt = default;
        bool defaultBool = default;
        string defaultString = default;
        Console.WriteLine(defaultInt + ", " + defaultBool + ", null? " + (defaultString == null));
    }
}

Mise en pratique

Savoir si un type est un type valeur ou référence permet de prévoir le comportement des copies, la possibilité d’utiliser la valeur null et la façon dont les méthodes peuvent le modifier. Cela contribue à produire un code correct et sans bogues.

using System;

struct Money { public decimal Amount; }
class Wallet { public decimal Amount; }

class Program
{
    static void Main()
    {
        Money m1 = new Money { Amount = 10 };
        Money m2 = m1; m2.Amount = 99;

        Wallet w1 = new Wallet { Amount = 10 };
        Wallet w2 = w1; w2.Amount = 99;

        Console.WriteLine("Money copy: " + m1.Amount + " (independent)");
        Console.WriteLine("Wallet ref: " + w1.Amount + " (shared)");
    }
}

Vérification rapide

Vérifiez votre compréhension des types valeur et des types référence.

Récapitulatif

Les types valeur (int, double, booléens, structures) stockent directement les données et sont copiés lors de l’affectation ; les types référence (classes, chaînes, tableaux) stockent une référence vers un objet du tas et copient cette référence. Seuls les types référence peuvent être nuls par défaut, et le comportement de l’affectation ainsi que l’égalité diffère entre ces deux familles.

using System;

struct V { public int N; }
class R { public int N; }

class Program
{
    static void Main()
    {
        V v1 = new V { N = 1 }; V v2 = v1; v2.N = 9;
        R r1 = new R { N = 1 }; R r2 = r1; r2.N = 9;
        Console.WriteLine(v1.N + " vs " + r1.N);
    }
}

Questions Fréquemment Posées

La leçon « Types valeur et types référence » est-elle gratuite ?

Oui — le texte complet de « Types valeur et types référence » 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 « Types valeur et types référence » ?

Observez comment chacun est stocké et copié. 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 1 sur 4.

Combien de temps prend la leçon « Types valeur et types référence » ?

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