Types référence et types valeur

1. Introduction

Imagine que tu as une boîte. Si c'est une boîte qui contient directement un objet (genre une boîte avec une pomme dedans), c'est comme un type valeur. Les données sont directement dans cette "boîte" (variable).

D'un autre côté, imagine que tu as une carte de visite avec une adresse. La carte elle-même n'est pas la maison, elle indique juste où trouver la maison. C'est comme un type référence. La variable contient pas les données elles-mêmes, mais une "carte de visite" – une adresse mémoire où ces données sont stockées.

Des exemples tout simples :

• int x = 5; // Type valeur : la variable x "contient" directement le nombre 5.
• string name = "John"; // Type référence : la variable name "contient" une référence vers la chaîne "John", qui est quelque part en mémoire.

Qui est quoi dans cette vie ?

Pour t'aider à t'y retrouver, voilà une liste générale des catégories des principaux types de données :

• Types primitifs : int, double, float, bool, char, byte, short, long, decimal etc.
• Structs (struct) : Toutes les structs que tu déclares avec le mot-clé struct.
• Enums (enum) : Types qui permettent de définir un ensemble de constantes nommées.

• Chaînes (string) : Même si les chaînes ont quelques particularités (elles sont immuables), elles restent des types référence.
• Tous les tableaux : Par exemple, int[], string[], YourCustomClass[].
• Toutes les classes (class) : Toutes les classes que tu déclares avec le mot-clé class.
• Délégués (delegate) : Types qui représentent des références vers des méthodes.
• Interfaces (interface) : Même si les interfaces ne sont pas des objets, une variable de type interface peut contenir une référence vers un objet qui implémente cette interface.
• Listes, dictionnaires et autres collections : Par exemple, List<T>, Dictionary<TKey, TValue>.
• Et en fait, tout ce qui n'est pas struct ou enum est par défaut un type référence en C#.

2. Copie de variables

Voilà où se cache la différence la plus importante dans la pratique. Quand tu assignes une variable à une autre, qu'est-ce qui est vraiment copié ?

A) Copie d'un type valeur (Value Type)

Quand tu copies un type valeur, tu crées une vraie copie indépendante des données elles-mêmes. C'est comme faire une photocopie d'un document : modifier une copie ne change rien à l'original ou aux autres copies.

    int a = 10;
int b = a; 					// b vaut aussi 10, mais c'est "sa propre copie"
Console.WriteLine($"Valeurs initiales : a = {a}, b = {b}"); // Valeurs initiales : a = 10, b = 10

b = 15; 					// On modifie b
Console.WriteLine($"Après modification de b : a = {a}, b = {b}"); // Après modification de b : a = 10, b = 15

Explication : La variable b a reçu sa propre copie de la valeur 10. Quand b a été modifié à 15, a est resté à sa valeur originale 10. Elles sont totalement indépendantes.

B) Copie d'un type référence (Reference Type)

Quand tu copies un type référence, tu copies juste la référence, c'est-à-dire "l'adresse" de l'objet en mémoire. Les deux variables pointent maintenant vers le même objet. C'est comme si tu donnais à deux personnes la même carte de visite : elles connaissent toutes les deux l'adresse de la même maison. Si l'une repeint un mur, l'autre verra aussi ce changement en allant à cette adresse.

Regardons ça avec un exemple de tableaux, parce que c'est super parlant (contrairement aux chaînes, qui ont leurs propres subtilités).

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 et arr1 pointent vers le même tableau en mémoire !

// Valeurs initiales : arr1[0] = 1, arr2[0] = 1
Console.WriteLine($"Valeurs initiales : arr1[0] = {arr1[0]}, arr2[0] = {arr2[0]}"); 

arr2[0] = 42; // On modifie un élément du tableau via arr2

// Après modification de arr2[0] : arr1[0] = 42, arr2[0] = 42
Console.WriteLine($"Après modification de arr2[0] : arr1[0] = {arr1[0]}, arr2[0] = {arr2[0]}"); 

Explication : Les deux variables (arr1 et arr2) contiennent la référence vers le même tableau en mémoire. Quand tu modifies arr2[0], tu modifies en fait le même tableau auquel les deux variables font référence. Donc arr1[0] affiche aussi la nouvelle valeur.

Subtilité avec les chaînes (string)

Les chaînes en C# sont des types référence, mais elles se comportent un peu différemment à cause de leur immutabilité (immutability). Ça veut dire qu'une fois créée, une chaîne ne peut pas être modifiée. Toute opération qui semble "modifier" une chaîne (genre concaténation, Replace()) crée en fait une nouvelle chaîne en mémoire.

string str1 = "Hello";
string str2 = str1; // str2 pointe vers le même objet "Hello" que str1

// str1 = "Hello", str2 = "Hello"
Console.WriteLine($"Valeurs initiales : str1 = \"{str1}\", str2 = \"{str2}\""); 

str2 = "Bye"; // Ici, un NOUVEL objet "Bye" est créé, et str2 pointe dessus

// str1 = "Hello", str2 = "Bye"
Console.WriteLine($"Après modification de str2 : str1 = \"{str1}\", str2 = \"{str2}\""); 

Explication : Au début, str1 et str2 pointaient vers le même objet "Hello". Quand str2 a reçu "Bye", C# n'a pas modifié l'objet "Hello" existant. Il a créé un nouvel objet "Bye" en mémoire, et str2 pointe maintenant dessus. str1 pointe toujours vers l'ancien "Hello". C'est une différence importante qui embrouille souvent les débutants.

3. Tableau des différences principales

4. Exemple dans une appli

Imaginons qu'on développe une petite appli console pour un questionnaire utilisateur. On a une struct pour les points d'examen et une classe pour le profil utilisateur.

// Type valeur : struct pour stocker les points
struct Score
{
    public int Points;
    public string Grade; // On ajoute ça pour l'exemple
}

// Type référence : classe pour le profil utilisateur
class User
{
    public string Name;
    public Score ExamScore; // Struct imbriquée
}

Copie d'une struct (Score)

Score score1 = new Score { Points = 100, Grade = "A" };
Score score2 = score1; // Tout le contenu de score1 est copié dans score2
Console.WriteLine($"score1: Points={score1.Points}, Grade={score1.Grade}"); // score1: Points=100, Grade=A
Console.WriteLine($"score2: Points={score2.Points}, Grade={score2.Grade}"); // score2: Points=100, Grade=A

score2.Points = 88;
score2.Grade = "B";

Console.WriteLine("--- Après modification de score2 ---");
Console.WriteLine($"score1: Points={score1.Points}, Grade={score1.Grade}"); // score1: Points=100, Grade=A (pas changé !)
Console.WriteLine($"score2: Points={score2.Points}, Grade={score2.Grade}"); // score2: Points=88, Grade=B

Résultat : score1 n'a pas changé. C'est parce que quand tu fais Score score2 = score1;, tout le contenu de score1 (tous ses champs) est copié dans score2. Les deux variables ont maintenant leurs propres données indépendantes.

Copie d'une classe (User)

User u1 = new User 
{ 
    Name = "Anna", 
    ExamScore = new Score { Points = 95, Grade = "A" } 
};
User u2 = u1; // Maintenant u2 et u1 pointent vers LE MÊME utilisateur en mémoire !
Console.WriteLine($"u1: Name={u1.Name}, Score={u1.ExamScore.Points}"); // u1: Name=Anna, Score=95
Console.WriteLine($"u2: Name={u2.Name}, Score={u2.ExamScore.Points}"); // u2: Name=Anna, Score=95

u2.Name = "Bob"; // On change le nom via u2
u2.ExamScore.Points = 60; // On change les points via u2
u2.ExamScore.Grade = "C";

Console.WriteLine("--- Après modification de u2 ---");
Console.WriteLine($"u1: Name={u1.Name}, Score={u1.ExamScore.Points}, Grade={u1.ExamScore.Grade}"); // u1: Name=Bob, Score=60, Grade=C
Console.WriteLine($"u2: Name={u2.Name}, Score={u2.ExamScore.Points}, Grade={u2.ExamScore.Grade}"); // u2: Name=Bob, Score=60, Grade=C

Résultat : u1 a aussi changé ! C'est parce que u1 et u2 pointaient au départ vers le même objet User en mémoire. Quand on a modifié les propriétés via u2 (genre u2.Name = "Bob";), on a modifié l'objet lui-même. Donc, quand on accède à u1.Name, on voit la nouvelle valeur. Même la struct imbriquée ExamScore a changé pour u1, car elle fait partie de l'objet User pointé par les deux références.

5. Ce qui se passe lors du passage en méthode

Comprendre comment les types sont passés aux méthodes est super important pour prévoir le comportement de ton programme.

Passage d'un type valeur (Value Type) à une méthode

Quand tu passes un type valeur à une méthode, par défaut c'est passé par valeur. Ça veut dire que la méthode reçoit une copie de la variable d'origine. Toute modification faite dans la méthode sur cette copie ne change rien à l'original en dehors de la méthode.

void AddTen(int x)
{
    Console.WriteLine($"Dans la méthode (avant modif) : x = {x}"); // Dans la méthode (avant modif) : x = 5
    x = x + 10; // x vaut maintenant 15, mais c'est une copie locale
    Console.WriteLine($"Dans la méthode (après modif) : x = {x}"); // Dans la méthode (après modif) : x = 15
    // Cette copie locale 'x' "meurt" à la sortie de la méthode.
}

int num = 5;
Console.WriteLine($"Avant appel de la méthode : num = {num}"); // Avant appel : num = 5
AddTen(num);
Console.WriteLine($"Après appel de la méthode : num = {num}"); // Après appel : num = 5 (pas changé !)

Résultat : La variable num n'a pas changé (5). x dans AddTen est une variable totalement séparée, initialisée avec la copie de la valeur de num.

Passage d'un type référence (Reference Type) à une méthode

Quand tu passes un type référence à une méthode, c'est aussi passé par valeur par défaut, mais c'est la valeur de la référence qui est copiée, pas l'objet lui-même. Ça veut dire que dans la méthode, tu as une copie de la "carte de visite" (adresse) de l'objet original. Les deux références (l'originale et celle dans la méthode) pointent vers le même objet en mémoire.

void RenameUser(User u)
{
    // Dans la méthode (avant modif) : u.Name = "Alice"
    Console.WriteLine($"Dans la méthode (avant modif) : u.Name = \"{u.Name}\""); 
    u.Name = "Nouveau nom"; // On modifie la propriété de l'objet pointé par 'u'
    // Dans la méthode (après modif) : u.Name = "Nouveau nom"
    Console.WriteLine($"Dans la méthode (après modif) : u.Name = \"{u.Name}\""); 
}

User user = new User { Name = "Alice" };
// Avant appel de la méthode : user.Name = "Alice"
Console.WriteLine($"Avant appel de la méthode : user.Name = \"{user.Name}\""); 
RenameUser(user); 
// Après appel de la méthode : user.Name = "Nouveau nom"
Console.WriteLine($"Après appel de la méthode : user.Name = \"{user.Name}\""); 

Résultat : Le nom de l'utilisateur est devenu "Nouveau nom". La méthode RenameUser a reçu une copie de la référence vers l'objet user. Avec cette copie de la référence, la méthode a pu accéder à l'objet original dans le tas et modifier sa propriété Name.

Important : Que se passe-t-il si, dans la méthode, on assigne un nouvel objet à la variable de type référence passée ?

void ReassignUser(User u)
{
    u = new User { Name = "Tout nouvel utilisateur" }; // 'u' pointe maintenant vers un nouvel objet
    Console.WriteLine($"Dans la méthode (après réaffectation) : u.Name = \"{u.Name}\"");
}

User originalUser = new User { Name = "Utilisateur original" };
Console.WriteLine($"Avant appel de ReassignUser : originalUser.Name = \"{originalUser.Name}\"");
ReassignUser(originalUser); 
Console.WriteLine($"Après appel de ReassignUser : originalUser.Name = \"{originalUser.Name}\""); // "Utilisateur original" - pas changé !

Résultat : originalUser n'a pas changé ! C'est parce que ReassignUser a reçu une copie de la référence. Quand u = new User(...) a été fait dans la méthode, la variable locale u pointe vers un tout nouvel objet. La référence originale originalUser pointe toujours vers l'ancien objet. C'est super important à comprendre !

6. "Larmes du débutant" : erreurs typiques et leurs causes

Comprendre les types référence et valeur peut être galère au début. Voilà quelques erreurs et confusions fréquentes :

Confusion avec la copie de tableaux : Les débutants pensent souvent que quand ils font arr2 = arr1;, ça crée une copie indépendante du tableau. En vrai, ce sont juste deux références vers le même tableau. C'est comme deux manettes pour la même console : ce que tu fais avec l'une se voit aussi avec l'autre. Pour créer une vraie copie indépendante, il faut cloner explicitement (genre int[] arr2 = (int[])arr1.Clone(); ou utiliser les méthodes Copy).

Attendre que les chaînes "changent par référence" : Comme string est un type référence, on croit parfois qu'il va se comporter comme un tableau pour les modifications. Mais à cause de l'immutabilité des chaînes, toute opération qui semble modifier crée en fait un nouvel objet string. Ça donne souvent des résultats inattendus et peut être inefficace si tu fais plein d'opérations sur des chaînes dans une boucle (dans ce cas, préfère StringBuilder).

Oublier le null : Les types valeur, sauf les types nullable (int?, bool?), ont toujours une valeur et ne peuvent jamais être null. Les types référence, eux, peuvent être null, c'est-à-dire ne pointer vers aucun objet. Essayer d'accéder à un membre d'un objet qui est null provoque le fameux NullReferenceException. Vérifie toujours les variables de type référence pour null avant de les utiliser si tu n'es pas sûr qu'elles sont définies.

Utiliser des classes au lieu de structs pour de petites données : Par habitude, on déclare parfois tout en classe. Mais pour des petits ensembles de données simples qui représentent un tout (genre un point Point { X, Y }, une couleur Color { R, G, B }), les structs peuvent être plus efficaces, car ils sont stockés sur la pile et copiés par valeur, ce qui réduit la charge du garbage collector. Mais les structs doivent rester immuables, petits, et ne pas contenir de types référence qui peuvent eux-mêmes être null ou changer d'état.

2

Mission

C# SELF, niveau 12, leçon 3

Bloqué

Comportement des tableaux comme type référence

Comportement des tableaux comme type référence

Ouvrir

2

Mission

C# SELF, niveau 12, leçon 3

Bloqué

Interaction avec les méthodes pour les types valeur et référence

Interaction avec les méthodes pour les types valeur et référence

Ouvrir