Comprendre les Pointeurs

Qu'est-ce qu'un Pointeur

Vous pouvez considérer les pointeurs comme des coordonnées. Ils nous indiquent des emplacements spécifiques dans la mémoire et nous permettent d'accéder aux données stockées à ces emplacements.

Lorsque vous déclarez un pointeur, vous créez une variable qui contient l'adresse mémoire d'une autre variable. Vous pouvez créer un pointeur en utilisant les opérateurs * et &.

pointer


              1234
            
int value = 42;

// `p_value` now holds the memory address of `value`
int* p_value = &value;

Pointeurs Nuls

Vous pouvez utiliser des mots-clés spéciaux pour représenter un pointeur nul null ou nullptr. Un pointeur nul ne pointe vers aucune adresse mémoire valide. C'est essentiellement un pointeur sans cible.

Vous pouvez également initialiser le pointeur entier à null (ou nullptr). Nous faisons cela lorsque nous ne voulons pas associer le pointeur à une valeur spécifique immédiatement.

null_pointer


              123
            
int* p_int = null; // `p_int` is initialized to be null

double* p_double = nullptr; // `p_double` is initialized to be null

Réaffectation des Pointeurs

Les pointeurs peuvent être réaffectés pour pointer vers différentes adresses mémoire. Cependant, réaffecter un pointeur sans gestion appropriée peut entraîner des problèmes tels que des fuites de mémoire ou des pointeurs pendants.

reassigning_pointers


              12345
            
int x = 42; // Create an integer variable and assign a value to it
int y = 43; // Create another integer variable

int* p_int = &x; // Make the `p_int` variable point to the address of the integer variable `x`
p_int = &y; // Reassign the `p_int` variable to `y`

Arithmétique des Pointeurs

L'arithmétique des pointeurs est un aspect fascinant des pointeurs. Elle vous permet de parcourir la mémoire en incrémentant ou décrémentant l'adresse détenue par un pointeur.

Par exemple, considérez le code suivant où nous créons un tableau d'entiers, puis définissons un pointeur pour contenir l'adresse du tableau. Puisqu'un tableau contient plusieurs éléments, un pointeur, par défaut, stocke l'adresse du premier élément, qui dans ce cas est l'entier 1.

pointer_arithmetic


              1234567891011
            
// Defining an array of integers
int arr[5] = {1, 2, 3, 4, 5};

// The pointer holds the memory address of the first element in the array
int* p_int = arr; 

// Incrementing the pointer makes the pointer point to the second value
p_int = p_int + 1;

// Dereference the pointer to get the actual second value
int second_element = *p_int; // Equals to `2`

Pour accéder au deuxième élément, incrémentez le pointeur de 1 puis déréférencez-le en utilisant l'opérateur (*). La déréférencement renvoie la valeur stockée à l'adresse mémoire détenue par le pointeur (dans ce cas, l'entier 2). Suivez les commentaires dans le code pour comprendre chaque étape !

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 1