Maîtriser le code unsafe C# : Guide des pointeurs et gestion mémoire

C# autorise l'utilisation de variables pointeur dans une fonction ou un bloc de code lorsqu'il est marqué par le modificateur unsafe. Le code unsafe ou code non managé est un bloc de code qui utilise une variable pointeur.

Pointeurs

Un pointeur est une variable dont la valeur est l'adresse d'une autre variable, c'est-à-dire l'adresse directe de l'emplacement mémoire. Comme pour toute variable ou constante, vous devez déclarer un pointeur avant de pouvoir l'utiliser pour stocker l'adresse d'une variable.

La forme générale d'une déclaration de pointeur est :

type *nom-var;

Voici des déclarations de pointeurs valides :

int *ip;  /* pointeur vers un entier */ 
double *dp; /* pointeur vers un double */ 
float *fp;  /* pointeur vers un float */ 
char *ch    /* pointeur vers un caractère */

L'exemple suivant illustre l'utilisation de pointeurs en C#, en utilisant le modificateur unsafe :

using System; 
namespace UnsafeCodeApplication { 
    class Program { 
        static unsafe void Main(string[] args) { 
            int var = 20; 
            int* p = &var; 
            Console.WriteLine("Donnée : {0} ", var); 
            Console.WriteLine("Adresse : {0}", (int)p); 
            Console.ReadKey(); 
        } 
    } 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Donnée : 20 
Adresse : 99215364

Au lieu de déclarer une méthode entière comme unsafe, vous pouvez également déclarer une partie du code comme unsafe. L'exemple de la section suivante montre cela.

Récupération de la valeur de données à l'aide d'un pointeur

Vous pouvez récupérer la valeur stockée à l'emplacement référencé par la variable pointeur, en utilisant la méthode ToString(). L'exemple suivant le démontre :

using System; 
namespace UnsafeCodeApplication { 
    class Program { 
        public static void Main() { 
            unsafe { 
                int var = 20; 
                int* p = &var; 
                Console.WriteLine("Donnée : {0} " , var); 
                Console.WriteLine("Donnée : {0} " , p->ToString()); 
                Console.WriteLine("Adresse : {0} " , (int)p); 
            } 
            Console.ReadKey(); 
        } 
    } 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Donnée : 20 
Donnée : 20 
Adresse : 77128984

Passage de pointeurs en paramètres aux méthodes

Vous pouvez passer une variable pointeur à une méthode en tant que paramètre. L'exemple suivant l'illustre :

using System; 
namespace UnsafeCodeApplication { 
    class TestPointer { 
        public unsafe void swap(int* p, int *q) { 
            int temp = *p; 
            *p = *q; 
            *q = temp; 
        } 
        public unsafe static void Main() { 
            TestPointer p = new TestPointer(); 
            int var1 = 10; 
            int var2 = 20; 
            int* x = &var1; 
            int* y = &var2; 
            Console.WriteLine("Avant échange : var1:{0}, var2: {1}", var1, var2); 
            p.swap(x, y); 
            Console.WriteLine("Après échange : var1:{0}, var2: {1}", var1, var2); 
            Console.ReadKey(); 
        } 
    } 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Avant échange : var1: 10, var2: 20 
Après échange : var1: 20, var2: 10

Accès aux éléments d'un tableau à l'aide d'un pointeur

En C#, un nom de tableau et un pointeur vers un type de données identique aux données du tableau ne sont pas du même type de variable. Par exemple, int *p et int[] p ne sont pas du même type. Vous pouvez incrémenter la variable pointeur p car elle n'est pas fixe en mémoire, mais l'adresse d'un tableau est fixe en mémoire et vous ne pouvez pas l'incrémenter.

Par conséquent, si vous devez accéder aux données d'un tableau en utilisant une variable pointeur, comme on le fait traditionnellement en C ou C++ (voir : Pointeurs C), vous devez fixer le pointeur en utilisant le mot-clé fixed.

L'exemple suivant le démontre :

using System; 
namespace UnsafeCodeApplication { 
    class TestPointer { 
        public unsafe static void Main() { 
            int[] list = {10, 100, 200}; 
            fixed(int *ptr = list) /* obtention de l'adresse du tableau dans le pointeur */ 
            for (int i = 0; i < 3; i++) { 
                Console.WriteLine("Adresse de list[{0}]={1}", i, (int)(ptr + i)); 
                Console.WriteLine("Valeur de list[{0}]={1}", i, *(ptr + i)); 
            } 
            Console.ReadKey(); 
        } 
    } 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Adresse de list[0] = 31627168 
Valeur de list[0] = 10 
Adresse de list[1] = 31627172 
Valeur de list[1] = 100 
Adresse de list[2] = 31627176 
Valeur de list[2] = 200

Compilation du code unsafe

Pour compiler du code unsafe, vous devez spécifier l'option de ligne de commande /unsafe avec le compilateur en ligne de commande.

Par exemple, pour compiler un programme nommé prog1.cs contenant du code unsafe, depuis la ligne de commande, donnez la commande :

csc /unsafe prog1.cs

Si vous utilisez l'IDE Visual Studio, vous devez activer l'utilisation du code unsafe dans les propriétés du projet.

Pour ce faire :

• Ouvrez les propriétés du projet en double-cliquant sur le nœud Propriétés dans l'Explorateur de solutions.

• Cliquez sur l'onglet Build (Génération).

• Sélectionnez l'option "Autoriser le code unsafe".