Mémo Programmation C# : pointeur

Un pointeur désigne une variable qui contient l’adresse d’une autre variable, (le type de cette autre variable devant être connu au moment de déclarer le pointeur).

Note : Les pointeurs sont à manipuler avec précaution, car ils peuvent être responsables, s’ils sont mal utilisés, d’un manque de fiabilité du programme. Ils sont cependant puissants et peuvent faire gagner en rapidité notre programme, c’est pourquoi nous verrons toutes les restrictions qui accompagnent leurs utilisation.

Un petit exemple que je commenterai sera plus parlant quant à l’intérêt des pointeurs…

public class Program{
     unsafe static void Main(){
           int number= 10; //déclaration de la variable
           Modify(&number);
          Console.WriteLine("number = "+ number); //affiche "number = 20"
     }

     unsafe static void Modify(int *pointer_number){
          *pointer_number = 20; //modifie la valeur de i
     }
}

Tout d’abord, vous aurez remarqué que les méthode utilisant les pointeurs sont qualifiées d’unsafe. Ceci est pour la simple raison d’attirer l’attention du développeur sur le danger potentiel d’une telle fonction.
Unsafe est donc utilisé pour qualifier la fonction Main parce que nous y prenons l’adresse de la variable number. Et pour la fonction Modify car nous y manipulons le pointeur de number.
Pour pouvoir compiler avec des méthodes qualifiées d’unsafe, il faudra aussi préciser dans les propriétés du programme que le code « unsafe » est accepté. cela se trouve dans :

Explorateur de solutions -> 
    clic droit sur "MonProjet" -> 
    Propriétes -> 
    Build -> Cocher la case "Unsafe"

Dans la fonction Main, la variable number est déclarée normalement, c’est au moment de la passer à la fonction Modify que nous écrivons &number.
& signifie que l’adresse de de la variable est passé et non sa valeur !

Lorsque la fonction Modify s’exécute, elle utilise le pointeur, soit *pointer_number et que donc que nous pointons directement sur la variable number. * déclare un pointeur !

Récapitulons :

int i = 10; int j = 60; int n = 0; //déclarations de variables
int *p; //déclaration d'un pointeur sur entier (int)
p = &i; //affecte à p l'adresse de i
n = *p; //affecte à n la valeur de l'entier pointé par p, soit i
p = &j; //affecte à p l'adresse de j
*p = 200; //affecte 200 à la variable pointé par p, soit maintenant j

Il est tout à fait possible de faire sans, mais pour une gestion de bibliothèque d’image par exemple, ils peuvent devenir des atouts 🙂