Dit artikel gaat over het pointer-to-pointer-concept in C++. De pointer naar pointer wijst of slaat het adres van een andere pointer op en maakt manipulatie van de pointers zelf mogelijk. Met dit concept kunnen we eenvoudig een aanwijzer vanaf een andere locatie in het geheugen wijzigen. Dubbele pointers zijn nuttig in dynamisch toegewezen geheugen of multidimensionale arrays om de elementen van een array te manipuleren. We zullen deze pointer-naar-pointer-werking en -gebruik in C++ bespreken met goede voorbeelden.
Scenario 1: Geheugenrepresentatie van aanwijzer naar aanwijzer
In dit scenario is het declareren van de dubbele pointer vergelijkbaar met de pointerdeclaratie met een extra asterisk (*) vóór de pointernaam. We kunnen gemakkelijk de geheugenlocatie van een dubbele pointer in C++ weergeven. Het codefragment van de pointer naar pointer wordt als volgt weergegeven:
#include
namespace std; gebruiken;
int. hoofd ( )
{
int-cijfer = vijftig ;
int * prr;
ptr = & cijfer;
int ** ptrr1;
prr1 = & prr;
uit << 'Het pointergeheugenadres is: \N ' ;
uit << 'ptrr (wijzer): ' << prr << ' \N ' ;
uit << '*ptrr1 (dubbele aanwijzer): ' <<* prr1 << ' \N ' ;
uit << ' De waarde die in de pointer wordt opgeslagen is: \N ' ;
uit << '*ptrr = ' <<* prr << eind;
uit << '**ptrr1 (aanwijzer naar aanwijzer) = ' <<** prr1 << eind;
opbrengst 0 ;
}
In de hoofdfunctie nemen we een variabele waarvan het geheugenadres in een pointer moet worden opgeslagen. Nu initialiseren we de “digit” -variabele. Daarna declareren we de 'ptrr' -aanwijzer die het 'cijferige' geheugenadres opslaat. Nu declareren we de dubbele aanwijzer met de naam “**ptrr1” waarin het adres van de “*ptrr” -aanwijzer is opgeslagen. Aan het einde van de code geven we het geheugen en de waarde van de aanwijzer en dubbele aanwijzer weer op het consolescherm. De uitvoer van deze code wordt hieronder vermeld:
Het geheugenadres van de “ptrr”-aanwijzer is “0x6ffe04”, en de “*ptrr1”-aanwijzer slaat ook het geheugenadres van de “ptrr”-aanwijzer op. De waarde die in de aanwijzer wordt opgeslagen, is “50”. In principe is het adres van de dubbele pointer altijd hetzelfde als het geheugenadres van de pointer.
Scenario 2: aanwijzer naar aanwijzer als functieparameter
In dit scenario zullen we leren hoe we de dubbele pointer in elke functie als parameter kunnen doorgeven om de tijdelijke geheugentoewijzing in elke variabele uit te voeren. Het codefragment van de functieparameter met dubbele aanwijzer wordt hieronder vermeld:
#include
void getMemoryAddress ( int ** dubbel_ptr ) {
jij weer = 200 ;
* dubbele_ptr = & temperatuur;
}
int. hoofd ( ) {
int * ptr_1;
int ** dubbele_ptr;
dubbele_ptr = & ptr_1;
getMemoryAddress ( dubbel_ptr ) ;
std::uit << 'Waarde van **double_ptr is: ' << ** dubbel_ptr << std::endl;
opbrengst 0 ;
}
Hier zullen we leren hoe het pointer-naar-pointer-concept werkt in C++. Houd er rekening mee dat er in het programma is aangegeven dat één pointer met een dubbele pointer werkt. Daarom bouwen we de functie 'getMemoryAddress'. We ontwerpen deze functie zo dat wanneer we de parameter doorgeven, deze automatisch het geheugenadres van de dubbele pointer krijgt.
In de functie nemen we de variabele “tempp” en de dubbele pointer “**double_ptr”. We geven het adres van de opgegeven variabele, die “tempp” is, door aan de dubbele pointer en de dubbele pointerwaarden als argument van de functie. Het programma geeft het resultaat van de hoofdfunctiecode weer op het consolescherm, dus alle dingen die in de hoofdfunctie voorkomen, zijn uitvoerbaar. We nemen de “ptr_1”-aanwijzer en de dubbele aanwijzer als “double_ptr” in de hoofdfunctie. We geven het adres van de pointer door aan de dubbele pointer.
Nu geven we de dubbele pointervariabele door in de override-functie en geven we de pointer door aan de pointervariabele in de uitvoerstroominstructie 'cout' om het resultaat van de dubbele pointer weer te geven.
Wanneer de compiler de override-functie bereikt, voert de compilerchecker waar deze functie is gedefinieerd de code binnen de functie uit en retourneert het resultaat naar de hoofdfunctie.
De uitvoer van deze code is als volgt bijgevoegd:
Resultaat: De waarde van de dubbele aanwijzer is 200.
Scenario 3: De 2D-array gebruiken met pointer-to-pointer
In dit voorbeeld behandelen we een 2D-array met een dubbele pointer. We nemen een array en geven het adres van een array door in de pointer. De volledige code van dit scenario wordt als volgt weergegeven:
int. hoofd ( ) {const in rijen = 3 ;
const int cols = 2 ;
int ** matrix = nieuwe int * [ rijen ] ;
voor ( int ik = 0 ; i < rijen; ++ik ) {
Matrix [ i ] = nieuwe int [ col ] ;
}
voor ( int ik = 0 ; i < rijen; ++ik ) {
voor ( int j = 0 ; J < cols; ++j ) {
Matrix [ i ] [ J ] = ik * cols + j;
}
}
voor ( int ik = 0 ; i < rijen; ++ik ) {
voor ( int j = 0 ; J < cols; ++j ) {
uit << Matrix [ i ] [ J ] << ' ' ;
}
uit << eind;
}
voor ( int ik = 0 ; i < rijen; ++ik ) {
verwijderen [ ] Matrix [ i ] ;
}
verwijderen [ ] Matrix;
opbrengst 0 ;
}
Zoals we allemaal weten, hebben we veel rijen en meerdere kolommen in een 2D-array. In de hoofdfunctie initialiseren we de rijen en kolommen met “const int”. Daarna wijzen we de geheugenruimte voor de rijen en de geheugenruimte voor de kolommen langs elke rij toe. We geven de waarde van het aantal rijen door als aanwijzer in de dubbele aanwijzer van de matrix als '**matrix'. In deze dubbele pointer wordt de lus van het aantal rijen uitgevoerd of waar. Vervolgens wordt nog een binnenlus uitgevoerd totdat de voorwaarde onwaar wordt.
Na de geheugentoewijzing kennen we opnieuw een waarde toe aan een array: een buitenste lus voor de rijen en een binnenste lus voor de kolommen van de 2D-array. In de binnenste lus wordt de waarde van rijen en kolommen toegewezen aan de dubbele aanwijzer en wordt een vereiste rekenkundige bewerking uitgevoerd. We geven de waarden van een 2D-array weer, zoals het aantal rijen en kolommen dat in het geheugen is toegewezen. Het aantal rijen en kolommen wijst altijd naar de dubbele aanwijzer die de rijen en kolomwaarden opslaat. Uiteindelijk ruimen we het geheugen op en maken we de toewijzing van deze array uit het geheugen in C++ ongedaan.
De uitvoer van de 2D-array met een dubbele pointer is als volgt bijgevoegd:
Scenario 4: De aanwijzers verwisselen met behulp van aanwijzer naar aanwijzer
Hier zullen we leren hoe we de pointers in C++ kunnen verwisselen door de dubbele pointer te declareren. Het codefragment van dit scenario is als volgt bijgevoegd:
#includeleegte ruil ( int ** ptrr_1, jij ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int. hoofd ( ) {
int x = vijftien , y = 25 ;
int * ptrrA = & X, * ptrrB = & En;
std::uit << 'Vóór het wisselen: *ptrrA is = ' << * ptrrA << ', *ptrrB is = ' << * ptrrB << std::endl;
ruil ( & prrA, & ptrrB ) ;
std::uit << 'Na het wisselen: *ptrrA is = ' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
opbrengst 0 ;
}
Eerst bouwen we de swap-functie, waarbij we beide pointers doorgeven als het functieargument. In de swap-functie nemen we de “temp”-aanwijzer en geven we de waarde van “pointer1” enige tijd door in “temp”. Vervolgens geven we de waarde van “pointer2” door aan “pointer1”. Uiteindelijk geven we de waarde van de “temp” -aanwijzer door aan de “pointer2”.
In de hoofdfunctie hebben we twee pointers nodig die we doorgeven of negeren in de functie 'swap'. We geven de adressen van variabelen door aan de gegeven pointers. Vervolgens wordt de waarde van de aanwijzer vóór en na het verwisselen van de aanwijzer weergegeven.
De uitvoer van deze code is als volgt bijgevoegd:
Zoals we kunnen zien, worden de waarden van de aanwijzer met succes verwisseld met behulp van een dubbele aanwijzer in C++.
Conclusie
We concludeerden dat de pointer naar pointer altijd het geheugenadres van elke pointer in C++ opslaat. We kunnen de dubbele pointer gebruiken om op elk moment tijdelijk de geheugenlocatie van een willekeurige pointer te gebruiken. Dit is een zeer effectieve manier om het geheugenadres indirect te manipuleren en de gegevens te benaderen.