Cet article concerne le concept de pointeur vers pointeur en C++. Le pointeur vers un pointeur pointe ou stocke l'adresse d'un autre pointeur et permet la manipulation des pointeurs eux-mêmes. Grâce à ce concept, nous pouvons facilement modifier un pointeur depuis un autre emplacement de la mémoire. Les pointeurs doubles sont utiles dans la mémoire allouée dynamiquement ou dans les tableaux multidimensionnels pour manipuler les éléments d'un tableau. Nous discuterons du fonctionnement et de l’utilisation de ce pointeur vers pointeur en C++ avec des exemples appropriés.
Scénario 1 : Représentation en mémoire d'un pointeur vers un pointeur
Dans ce scénario, la déclaration du double pointeur est similaire à la déclaration du pointeur avec un astérisque supplémentaire (*) avant le nom du pointeur. Nous pouvons facilement représenter l’emplacement mémoire d’un double pointeur en C++. L'extrait de code du pointeur vers le pointeur est donné comme suit :
#include
en utilisant l'espace de noms std ;
int main ( )
{
chiffre entier = cinquante ;
int * ptrr;
ptrr = & chiffre;
int ** ptrr1;
ptrr1 = & ptrr;
cout << 'L'adresse mémoire du pointeur est : \n ' ;
cout << 'ptrr (pointeur) : ' << ptrr << ' \n ' ;
cout << '*ptrr1 (double pointeur) : ' <<* ptrr1 << ' \n ' ;
cout << ' La valeur stockée dans le pointeur est : \n ' ;
cout << '*ptrr = ' <<* ptrr << fin;
cout << '**ptrr1 (pointeur vers pointeur) = ' <<** ptrr1 << fin;
retour 0 ;
}
Dans la fonction principale, nous prenons une variable dont l'adresse mémoire doit être stockée dans un pointeur. Maintenant, nous initialisons la variable « digit ». Après cela, nous déclarons le pointeur « ptrr » qui stocke l'adresse mémoire « chiffre ». Maintenant, nous déclarons le double pointeur dont le nom est « **ptrr1 » qui stocke l'adresse du pointeur « *ptrr ». A la fin du code, on affiche la mémoire et la valeur du pointeur et du double pointeur sur l'écran de la console. La sortie de ce code est mentionnée comme suit :
L'adresse mémoire du pointeur « ptrr » est « 0x6ffe04 » et le pointeur « *ptrr1 » stocke également l'adresse mémoire du pointeur « ptrr ». La valeur stockée à l’intérieur du pointeur est « 50 ». Fondamentalement, l’adresse du double pointeur est toujours la même que l’adresse mémoire du pointeur.
Scénario 2 : Pointeur vers pointeur comme paramètre de fonction
Dans ce scénario, nous apprendrons comment passer le double pointeur dans n'importe quelle fonction en tant que paramètre pour effectuer l'allocation de mémoire temporaire dans n'importe quelle variable. L'extrait de code du paramètre de fonction avec double pointeur est mentionné dans ce qui suit :
#include
annuler getMemoryAddress ( int ** double_ptr ) {
tu fais du temps = 200 ;
* double_ptr = & température ;
}
int main ( ) {
int * ptr_1;
int ** double_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( double_ptr ) ;
std :: cout << 'La valeur de **double_ptr est : ' << ** double_ptr << std::endl;
retour 0 ;
}
Ici, nous allons apprendre comment fonctionne le concept de pointeur vers pointeur en C++. N'oubliez pas qu'un pointeur est déclaré dans le programme pour fonctionner avec un double pointeur. Nous construisons donc la fonction « getMemoryAddress ». Nous concevons cette fonction de manière à ce que lorsque nous passons le paramètre, elle obtienne automatiquement l'adresse mémoire du double pointeur.
Dans la fonction, on prend la variable « tempp » et le double pointeur « **double_ptr ». Nous transmettons l'adresse de la variable spécifiée qui est « tempp » au double pointeur et les valeurs du double pointeur comme argument de la fonction. Le programme affiche le résultat du code de la fonction principale sur l'écran de la console, de sorte que tout ce qui se trouve dans la fonction principale est exécutable. Nous prenons le pointeur « ptr_1 » et le pointeur double comme « double_ptr » dans la fonction principale. Nous transmettons l'adresse du pointeur au double pointeur.
Maintenant, nous passons la variable double pointeur dans la fonction override et passons le pointeur vers la variable pointeur dans l'instruction de flux de sortie « cout » pour afficher le résultat du double pointeur.
Lorsque le compilateur atteint la fonction de remplacement, le vérificateur du compilateur dans lequel cette fonction est définie exécute le code à l'intérieur de la fonction et renvoie le résultat à la fonction principale.
La sortie de ce code est jointe ci-dessous :
Résultat : La valeur du double pointeur est 200.
Scénario 3 : Utiliser le tableau 2D avec un pointeur vers un pointeur
Dans cet exemple, nous traiterons d’un tableau 2D possédant un double pointeur. Nous prenons un tableau et passons l'adresse d'un tableau dans le pointeur. Le code complet de ce scénario est fourni comme suit :
int main ( ) {const int lignes = 3 ;
const int colonnes = 2 ;
int ** matrice = nouveau int * [ Lignes ] ;
pour ( int je = 0 ; je < Lignes; ++je ) {
matrice [ je ] = nouveau entier [ cols ] ;
}
pour ( int je = 0 ; je < Lignes; ++je ) {
pour ( entier j = 0 ; j < cols; ++j ) {
matrice [ je ] [ j ] = je * col + j;
}
}
pour ( int je = 0 ; je < Lignes; ++je ) {
pour ( entier j = 0 ; j < cols; ++j ) {
cout << matrice [ je ] [ j ] << ' ' ;
}
cout << fin;
}
pour ( int je = 0 ; je < Lignes; ++je ) {
supprimer [ ] matrice [ je ] ;
}
supprimer [ ] matrice;
retour 0 ;
}
Comme nous le savons tous, nous avons de nombreuses lignes et plusieurs colonnes dans un tableau 2D. Dans la fonction principale, nous initialisons les lignes et les colonnes qui ont « const int ». Après cela, nous allouons l’espace mémoire pour les lignes et l’espace mémoire pour les colonnes le long de chaque ligne. Nous transmettons la valeur du nombre de lignes sous forme de pointeur dans le double pointeur de la matrice sous la forme « **matrice ». Dans ce double pointeur, la boucle du nombre de lignes est exécutée ou vraie. Ensuite, une autre boucle interne est exécutée jusqu'à ce que la condition devienne fausse.
Après l'allocation de mémoire, nous attribuons à nouveau une valeur dans un tableau : une boucle externe pour les lignes et une boucle interne pour les colonnes du tableau 2D. Dans la boucle interne, la valeur des lignes et des colonnes est affectée au double pointeur et effectue une opération arithmétique requise. Nous affichons les valeurs d'un tableau 2D comme le nombre de lignes et de colonnes allouées dans la mémoire. Le nombre de lignes et de colonnes pointe toujours vers le double pointeur qui stocke les valeurs des lignes et des colonnes. En fin de compte, nous vidons la mémoire et libérons ce tableau de la mémoire en C++.
La sortie du tableau 2D avec un double pointeur est jointe comme suit :
Scénario 4 : Échanger les pointeurs à l'aide d'un pointeur contre un pointeur
Ici, nous allons apprendre comment échanger les pointeurs en C++ en déclarant le double pointeur. L'extrait de code de ce scénario est joint ci-dessous :
#includeéchange nul ( int ** ptrr_1, vous ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int main ( ) {
entier x = quinze , y = 25 ;
int * ptrrA = & X, * ptrrB = & et;
std :: cout << 'Avant l'échange : *ptrrA est = ' << * ptrrA << ', *ptrrB est = ' << * ptrrB << std::endl;
échanger ( & ptrrA, & ptrrB ) ;
std :: cout << 'Après l'échange : *ptrrA est = ' << * ptrrA << ', *ptrrB est = ' << * ptrrB << std::endl;
retour 0 ;
}
Tout d’abord, nous construisons la fonction swap, en passant les deux pointeurs comme argument de fonction. Dans la fonction swap, nous prenons le pointeur « temp » et passons la valeur de « pointer1 » dans « temp » pendant un certain temps. Ensuite, nous passons la valeur de « pointer2 » à « pointer1 ». Au final, on passe la valeur du pointeur « temp » au « pointer2 ».
Dans la fonction principale, nous avons besoin de deux pointeurs que nous transmettons ou remplaçons dans la fonction « swap ». Nous transmettons les adresses des variables aux pointeurs donnés. Ensuite, la valeur du pointeur avant et après l’échange du pointeur est affichée.
La sortie de ce code est jointe ci-dessous :
Comme nous pouvons le voir, les valeurs du pointeur sont échangées avec succès à l’aide d’un double pointeur en C++.
Conclusion
Nous avons conclu que le pointeur vers le pointeur stocke toujours l’adresse mémoire de tout pointeur en C++. Nous pouvons utiliser le double pointeur pour utiliser temporairement l'emplacement mémoire de n'importe quel pointeur à tout moment. C'est un moyen très efficace de manipuler indirectement l'adresse mémoire et d'approcher les données.