Pointeurs et tableaux C++

Dans ce didacticiel, nous allons découvrir la relation entre les tableaux et les pointeurs à l'aide d'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 également stocker l'adresse des cellules d'un tableau.

Prenons cet exemple :

int *ptr;
int arr[5];

// store the address of the first
// element of arr in ptr
ptr = arr;

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

Notez que nous avons utilisé arr au lieu de &arr[0] . C'est parce que les deux sont identiques. Ainsi, 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 devions 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 puis ptr + 3 pointera vers le quatrième élément. Par exemple,

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

ptr + 1 is equivalent to &arr[1];
ptr + 2 is equivalent to &arr[2];
ptr + 3 is equivalent to &arr[3];
ptr + 4 is equivalent to &arr[4];

De même, nous pouvons accéder aux éléments à l'aide du pointeur unique. Par exemple,

// use dereference operator
*ptr == arr[0];
*(ptr + 1) is equivalent to arr[1];
*(ptr + 2) is equivalent to arr[2];
*(ptr + 3) is equivalent to arr[3];
*(ptr + 4) is equivalent to arr[4];

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

ptr - 2 is equivalent to &arr[0];
ptr - 1 is equivalent to &arr[1]; 
ptr + 1 is equivalent to &arr[3];
ptr + 2 is equivalent to &arr[4];

Remarque : L'adresse entre ptr et ptr + 1 diffère de 4 octets. C'est parce que ptr est un pointeur vers un int Les données. 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 char tapez data, puis 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 C++

// C++ Program to display address of each element of an array 

#include <iostream>
using namespace std;

int main()
{
    float arr[3];

    // declare pointer variable
    float *ptr;
    
    cout << "Displaying address using arrays: " << endl;

    // use for loop to print addresses of all array elements
    for (int i = 0; i < 3; ++i)
    {
        cout << "&arr[" << i << "] = " << &arr[i] << endl;
    }

    // ptr = &arr[0]
    ptr = arr;

    cout<<"\nDisplaying address using pointers: "<< endl;

    // use for loop to print addresses of all array elements
    // using pointer notation
    for (int i = 0; i < 3; ++i)
    {
        cout << "ptr + " << i << " = "<< ptr + i << endl;
    }

    return 0;
}

Sortie

Displaying address using arrays: 
&arr[0] = 0x61fef0
&arr[1] = 0x61fef4
&arr[2] = 0x61fef8

Displaying address using pointers: 
ptr + 0 = 0x61fef0
ptr + 1 = 0x61fef4
ptr + 2 = 0x61fef8

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

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

Dans la plupart des contextes, les noms de tableau se décomposent 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 les mêmes.

Il existe quelques cas où les noms de tableaux ne se désintègrent pas en pointeurs. Pour en savoir plus, consultez :Quand le nom du tableau ne se désintègre-t-il pas en un pointeur ?

Exemple 2 :Nom du tableau utilisé comme pointeur

// C++ Program to insert and display data entered by using pointer notation.

#include <iostream>
using namespace std;

int main() {
    float arr[5];
    
   // Insert data using pointer notation
    cout << "Enter 5 numbers: ";
    for (int i = 0; i < 5; ++i) {

        // store input number in arr[i]
        cin >> *(arr + i) ;

    }

    // Display data using pointer notation
    cout << "Displaying data: " << endl;
    for (int i = 0; i < 5; ++i) {

        // display value of arr[i]
        cout << *(arr + i) << endl ;

    }

    return 0;
}

Sortie

Enter 5 numbers: 2.5
3.5
4.5
5
2
Displaying data: 
2.5
3.5
4.5
5
2

Ici,

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];
```
Notez que nous n'avons pas déclaré de variable de pointeur distincte, mais que nous utilisons plutôt le nom de tableau arr pour la notation du pointeur.

Comme nous le savons déjà, le nom du tableau arr pointe sur le premier élément du tableau. Donc, on peut penser à arr comme agissant comme un pointeur.
De même, nous avons ensuite utilisé for boucle pour afficher les valeurs de arr en utilisant la notation de pointeur.
```
cout << *(arr + i) << endl ;
```
Ce code est équivalent à
```
cout << arr[i] << endl ;
```

Pointeurs C++ Appel C++ par référence :utilisation de pointeurs [avec exemples]

Langue C