Place à la pratique

Maintenant que vous comprenez comment fonctionne la mémoire, nous allons passer à la pratique en C.
La première chose à savoir sur les pointeurs c'est comment les déclarer.

1. La déclaration des pointeurs :
Nous avons dit dans les parties précédentes que les pointeurs étaient des variables. Il se déclare donc de la même manière. A la seule différence près c'est qu'il faut rajouter '*' derrière le type.

type* mavariable;

Pourquoi un pointeur doit prendre un type ?
Tout simplement pour savoir combien d'octets il doit lire quand vous lui demandez de retourner la valeur.
Si vous voulez pointer sur un char :

char* mavariable;

Si vous voulez pointer sur un entier:

int* mavariable;

L'étoile ('*') signifie quoi ?
L'étoile veut dire que notre variable ne contient pas un char (ou un int) mais bien l'adresse d'un char (ou d'un int).

Que ce passe t'il en mémoire ?
Tout simplement on réserve l'espace mémoire demander (char = 1 octet, int = 4 octets) et on fait pointer notre pointeur sur cette adresse.

La case en rouge est l'espace alloué (pour un char) au moment de la déclaration du pointeur. Cet espace est vide (elle peut contenir tout et n'importe quoi).

2. L'initialisation des pointeurs :
C'est bien de créer un pointeur mais il est bien mieux de lui ajouter une valeur !
Il existe quatre façons d'initialiser un pointeur qui fonctionne dans tous les cas.

Méthode 1 :

int* mavariable = nullptr;

On indique que notre pointeur pointe sur rien.

Méthode 2 :

int* mavariable = &i;

On indique que notre pointeur pointe sur l'adresse de la variable 'i'.

Méthode 3 :

int* mavariable = new int[10];

On indique que notre pointeur pointe sur une adresse qui peux contenir 10 int de suite dans la RAM.

Méthode 4 :

int* mavariable = new int(52);

On indique que notre pointeur pointe sur une adresse qui contient la valeur 52.

3. Les opérateurs :
Dans la partie sur l'initialisation juste au dessus vous avez pu voir le symbole '&'. Ce signe est en fait un opérateur.
Dans la notion de pointeur il existe deux opérateurs.

Le premier permet de récupérer ce que pointe un pointeur. Cette opérateur est tout simplement l'étoile '*'.
Prenons pour exemple :

int* mavariable = new int[2];
mavariable[0] = 5;
mavariable[1] = 10;

Si nous appelons '*mavariable' nous allons avoir ce que pointe directement le pointeur. Donc la première case du tableau qui est 5.

int* mavariable = new int[2];
mavariable[0] = 5;
mavariable[1] = 10;
printf("%d", *mavariable);

>>>5

Si nous incrémentons de 1 l'adresse que pointe notre pointeur nous allons donc obtenir la deuxième case de notre tableau.

int* mavariable = new int[2];
mavariable[0] = 5;
mavariable[1] = 10;
printf("%d", *(mavariable+1));

>>>10

Le deuxième opérateur est le '&'. Il permet de retourner l'adresse d'une variable.

int* mavariable = new int[2];
mavariable[0] = 5;
mavariable[1] = 10;
printf("%p", &mavariable);

>>>0054FF0C

Nous obtenons bien l'adresse du pointeur.
Pour obtenir l'adresse de ce que pointe le pointeur (donc de la valeur 5) nous pouvons faire :

int* mavariable = new int[2];
mavariable[0] = 5;
mavariable[1] = 10;
printf("%p", &(*mavariable));

>>>00A9CFB8

Nous pouvons maintenant expliquer l'initialisation des pointeurs qui utilise '&'. Le but d'un pointeur est de pointer sur l'adresse d'une autre case. Il faut donc qu'il ait comme valeur l'adresse d'une autre variable :

int* mavariable = &i;

Petit exemple pour montrer le fonctionnement :

int i = 48;
printf("adresse de i : %p\n", &i);
printf("valeur de i : %d\n\n", i);

int* mavariable = &i;
printf("adresse de mavariable  : %p\n", &mavariable);
printf("valeur de mavariable  : %p\n\n", mavariable);

printf("adresse de ce que pointe mavariable  : %p\n", &(*mavariable));
printf("valeur de ce que pointe mavariable  : %d\n\n", *mavariable);

>>>adresse de i : 0076F96C
valeur de i : 48

adresse de mavariable : 0076F970
valeur de mavariable : 0076F96C

adresse de ce que pointe mavariable : 0076F96C
valeur de ce que pointe mavariable : 48