Pointeurs et tableaux en C++ : Maîtriser leur relation

Pointeurs et tableaux en C++

Dans ce tutoriel, nous apprendrons la relation entre les tableaux et les pointeurs avec des exemples.

En C++, les pointeurs sont des variables qui contiennent les adresses d'autres variables. Non seulement un pointeur peut stocker l'adresse d'une seule variable, mais il peut aussi stocker l'adresse des cellules d'un tableau.

Considérez cet exemple :

int *ptr;
int arr[5];
// stocker l'adresse du premier élément de arr dans ptr
ptr = arr;

Ici, ptr est une variable pointeur tandis que arr est un tableau int. Le code ptr = arr; stocke l'adresse du premier élément du tableau dans la variable ptr.

Remarquez que nous avons utilisé arr au lieu de &arr[0]. C'est parce que les deux sont identiques. Donc le code ci-dessous est le même que le code ci-dessus.

int *ptr;
int arr[5];
ptr = &arr[0];

Les adresses pour le reste des éléments du tableau sont données par &arr[1], &arr[2], &arr[3] et &arr[4].

---

Pointer vers tous les éléments du tableau

Supposons que nous ayons besoin de pointer vers le quatrième élément du tableau en utilisant le même pointeur ptr.

Ici, si ptr pointe vers le premier élément dans l'exemple ci-dessus, alors ptr + 3 pointera vers le quatrième élément. Par exemple,

int *ptr;
int arr[5];
ptr = arr;
ptr + 1 est équivalent à &arr[1];
ptr + 2 est équivalent à &arr[2];
ptr + 3 est équivalent à &arr[3];
ptr + 4 est équivalent à &arr[4];

De même, nous pouvons accéder aux éléments en utilisant le pointeur unique. Par exemple,

// utilisation de l'opérateur de déréférencement
*ptr == arr[0];
*(ptr + 1) est équivalent à arr[1];
*(ptr + 2) est équivalent à arr[2];
*(ptr + 3) est équivalent à arr[3];
*(ptr + 4) est équivalent à arr[4];

Supposons que nous ayons initialisé ptr = &arr[2]; alors

ptr - 2 est équivalent à &arr[0];
ptr - 1 est équivalent à &arr[1];
ptr + 1 est équivalent à &arr[3];
ptr + 2 est équivalent à &arr[4];

Note : L'adresse entre ptr et ptr + 1 diffère de 4 octets. C'est parce que ptr est un pointeur vers une donnée int. Et la taille de int est de 4 octets dans un système d'exploitation 64 bits.

De même, si le pointeur ptr pointe vers des données de type char, alors l'adresse entre ptr et ptr + 1 est de 1 octet. C'est parce que la taille d'un caractère est de 1 octet.

---

Exemple 1 : Pointeurs et tableaux en C++

// Programme C++ pour afficher l'adresse de chaque élément d'un tableau
#include <iostream>
using namespace std;

int main() {
    float arr[3];
    // déclaration de la variable pointeur
    float *ptr;
    cout << "Affichage des adresses en utilisant les tableaux : " << endl;
    // utilisation de la boucle for pour afficher les adresses de tous les éléments du tableau
    for (int i = 0; i < 3; ++i) {
        cout << "&arr[" << i << "] = " << &arr[i] << endl;
    }
    // ptr = &arr[0]
    ptr = arr;
    cout << "\nAffichage des adresses en utilisant les pointeurs : " << endl;
    // utilisation de la boucle for pour afficher les adresses de tous les éléments du tableau en utilisant la notation pointeur
    for (int i = 0; i < 3; ++i) {
        cout << "ptr + " << i << " = " << ptr + i << endl;
    }
    return 0;
}

Sortie

Affichage des adresses en utilisant les tableaux:
&arr[0] = 0x61fef0
&arr[1] = 0x61fef4
&arr[2] = 0x61fef8
Affichage des adresses en utilisant les pointeurs:
ptr + 0 = 0x61fef0
ptr + 1 = 0x61fef4
ptr + 2 = 0x61fef8

Dans le programme ci-dessus, nous avons d'abord simplement affiché les adresses des éléments du tableau sans utiliser la variable pointeur ptr.

Ensuite, nous avons utilisé le pointeur ptr pour pointer vers l'adresse de a[0], ptr + 1 pour pointer vers l'adresse de a[1], et ainsi de suite.

---

Dans la plupart des contextes, les noms de tableaux se dégradent en pointeurs. En termes simples, les noms de tableaux sont convertis en pointeurs. C'est la raison pour laquelle nous pouvons utiliser des pointeurs pour accéder aux éléments des tableaux.

Cependant, nous devons nous rappeler que les pointeurs et les tableaux ne sont pas la même chose.

Il y a quelques cas où les noms de tableaux ne se dégradent pas en pointeurs. Pour en savoir plus, visitez : Quand le nom du tableau ne se dégrade-t-il pas en pointeur ?

---

Exemple 2 : Nom de tableau utilisé comme pointeur

// Programme C++ pour insérer et afficher des données saisies en utilisant la notation pointeur.
#include <iostream>
using namespace std;

int main() {
    float arr[5];
    // Insertion des données en utilisant la notation pointeur
    cout << "Entrez 5 nombres : ";
    for (int i = 0; i < 5; ++i) {
        // stocker le nombre saisi dans arr[i]
        cin >> *(arr + i);
    }
    // Affichage des données en utilisant la notation pointeur
    cout << "Affichage des données : " << endl;
    for (int i = 0; i < 5; ++i) {
        // afficher la valeur de arr[i]
        cout << *(arr + i) << endl;
    }
    return 0;
}

Sortie

Entrez 5 nombres: 2.5 3.5 4.5 5 2
Affichage des données:
2.5
3.5
4.5
5
2

Ici,

1. Nous avons d'abord utilisé la notation pointeur pour stocker les nombres saisis par l'utilisateur dans le tableau arr.

   cin >> *(arr + i) ;

   Ce code est équivalent au code ci-dessous :

   cin >> arr[i];

   Remarquez que nous n'avons pas déclaré de variable pointeur séparée, mais plutôt que nous utilisons le nom du tableau arr pour la notation pointeur.

   Comme nous le savons déjà, le nom du tableau arr pointe vers le premier élément du tableau. Donc, nous pouvons considérer arr comme agissant comme un pointeur.

2. De même, nous avons ensuite utilisé la boucle for pour afficher les valeurs de arr en utilisant la notation pointeur.

   cout << *(arr + i) << endl ;

   Ce code est équivalent à

   cout << arr[i] << endl ;