Denne artikel handler om pointer to pointer-konceptet i C++. Pointeren til pointer peger eller gemmer adressen på en anden pointer og muliggør manipulation af selve pointerne. Ved at bruge dette koncept kan vi nemt ændre en pointer fra et andet sted i hukommelsen. Dobbelte pointere er gavnlige i dynamisk allokeret hukommelse eller multidimensionelle arrays til at manipulere elementerne i et array. Vi vil diskutere denne pointer til pointerarbejde og -brug i C++ med rigtige eksempler.
Scenarie 1: Hukommelsesrepræsentation af pointer til pointer
I dette scenarie svarer erklæringen af dobbeltmarkøren til pointererklæringen med en ekstra stjerne (*) før markørens navn. Vi kan nemt repræsentere hukommelsesplaceringen af en dobbeltpointer i C++. Kodestykket for markøren til markøren er givet i følgende:
#include
bruger navneområde std;
int main ( )
{
int ciffer = halvtreds ;
int * ptrr;
ptrr = & ciffer;
int ** ptrr1;
ptrr1 = & ptrr;
cout << 'Pointerhukommelsesadressen er: \n ' ;
cout << 'ptrr (peger): ' << ptrr << ' \n ' ;
cout << '*ptrr1 (dobbeltmarkør): ' <<* ptrr1 << ' \n ' ;
cout << ' Værdien gemt i markøren er: \n ' ;
cout << '*ptrr = ' <<* ptrr << endl;
cout << '**ptrr1 (peger til peger) = ' <<** ptrr1 << endl;
Vend tilbage 0 ;
}
I hovedfunktionen tager vi en variabel, hvis hukommelsesadresse skal lagres i en pointer. Nu initialiserer vi 'ciffer'-variablen. Derefter erklærer vi 'ptrr'-markøren, der gemmer 'cifret' hukommelsesadressen. Nu erklærer vi den dobbelte markør, hvis navn er '**ptrr1', der gemmer adressen på '*ptrr'-markøren. I slutningen af koden viser vi hukommelsen og værdien af markøren og dobbeltmarkøren på konsolskærmen. Outputtet af denne kode er nævnt i følgende:
Hukommelsesadressen for 'ptrr'-markøren er '0x6ffe04', og '*ptrr1'-markøren gemmer også hukommelsesadressen for 'ptrr'-markøren. Værdien, der er gemt inde i markøren, er '50'. Grundlæggende er adressen på dobbeltmarkøren altid den samme som markørens hukommelsesadresse.
Scenarie 2: Pointer til Pointer som funktionsparameter
I dette scenarie vil vi lære, hvordan man sender dobbeltpointeren i enhver funktion som en parameter for at udføre den midlertidige hukommelsestildeling i enhver variabel. Kodestykket til funktionsparameteren med dobbelt pointer er nævnt i det følgende:
#include
ugyldig getMemoryAddress ( int ** dobbelt_ptr ) {
du vejr = 200 ;
* double_ptr = & Midlertidig;
}
int main ( ) {
int * ptr_1;
int ** dobbelt_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( dobbelt_ptr ) ;
std::cout << 'Værdien af **double_ptr er: ' << ** dobbelt_ptr << std::endl;
Vend tilbage 0 ;
}
Her lærer vi, hvordan peger-til-peger-konceptet fungerer i C++. Husk, at en pointer er erklæret i programmet til at arbejde med en dobbelt pointer. Så vi bygger funktionen 'getMemoryAddress'. Vi designer denne funktion, så når vi sender parameteren, får den automatisk hukommelsesadressen på dobbeltmarkøren.
I funktionen tager vi variablen 'tempp' og dobbeltpointeren '**double_ptr'. Vi videregiver adressen på den angivne variabel, som er 'tempp', til den dobbelte pointer og dobbeltpointerværdierne som et argument for funktionen. Programmet viser resultatet af hovedfunktionskoden på konsolskærmen, så alle de ting, der er i hovedfunktionen, er eksekverbare. Vi tager 'ptr_1'-markøren og den dobbelte pointer som 'double_ptr' i hovedfunktionen. Vi videregiver adressen på markøren til dobbeltmarkøren.
Nu sender vi den dobbelte pointer-variabel i tilsidesættelsesfunktionen og sender pointeren til pointer-variablen i 'cout'-outputstrømsætningen for at vise resultatet af den dobbelte pointer.
Når compileren når tilsidesættelsesfunktionen, udfører compilerkontrollen, hvor denne funktion er defineret, koden inde i funktionen og returnerer resultatet til hovedfunktionen.
Outputtet af denne kode er vedhæftet i følgende:
Resultat: Værdien af dobbeltpointeren er 200.
Scenarie 3: Brug af 2D-arrayet med Pointer to Pointer
I dette eksempel vil vi beskæftige os med et 2D-array med en dobbelt pointer. Vi tager et array og sender adressen på et array i markøren. Den komplette kode for dette scenarie leveres som følger:
int main ( ) {const int rows = 3 ;
const int cols = 2 ;
int ** matrix = ny int * [ rækker ] ;
til ( int i = 0 ; jeg < rækker; ++i ) {
matrix [ jeg ] = ny int [ cols ] ;
}
til ( int i = 0 ; jeg < rækker; ++i ) {
til ( int j = 0 ; j < cols; ++j ) {
matrix [ jeg ] [ j ] = i * cols + j;
}
}
til ( int i = 0 ; jeg < rækker; ++i ) {
til ( int j = 0 ; j < cols; ++j ) {
cout << matrix [ jeg ] [ j ] << ' ' ;
}
cout << endl;
}
til ( int i = 0 ; jeg < rækker; ++i ) {
slette [ ] matrix [ jeg ] ;
}
slette [ ] matrix;
Vend tilbage 0 ;
}
Som vi alle ved, har vi mange rækker og flere kolonner i et 2D-array. I hovedfunktionen initialiserer vi de rækker og kolonner, der har 'const int'. Derefter tildeler vi hukommelsespladsen til rækkerne og hukommelsespladsen til kolonnerne langs hver række. Vi sender værdien af antallet af rækker som en pointer i matrix-dobbeltmarkøren som '**matrix'. I denne dobbelte pointer udføres løkken af antallet af rækker eller sand. Derefter udføres en anden indre løkke, indtil betingelsen bliver falsk.
Efter hukommelsesallokeringen tildeler vi igen en værdi i et array: en ydre sløjfe for rækkerne og en indre sløjfe til kolonnerne i 2D-arrayet. I den indre sløjfe tildeles værdien af rækker og kolonner til dobbeltmarkøren og udfører en påkrævet aritmetisk operation. Vi viser værdierne af et 2D-array som antallet af rækker og kolonner, der er allokeret i hukommelsen. Antallet af rækker og kolonner peger altid på den dobbelte markør, der gemmer rækkerne og kolonneværdierne. I sidste ende rydder vi hukommelsen og deallokerer dette array fra hukommelsen i C++.
Outputtet fra 2D-arrayet med en dobbelt pointer er vedhæftet i følgende:
Scenarie 4: Skift peger ved hjælp af peger til peger
Her vil vi lære, hvordan man bytter peger i C++ ved at erklære dobbeltmarkøren. Kodestykket til dette scenarie er vedhæftet i følgende:
#includeugyldigt bytte ( int ** ptrr_1, dig ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int main ( ) {
int x = femten , y = 25 ;
int * ptrrA = & x, * ptrrB = & og;
std::cout << 'Før swap: *ptrrA er = ' << * ptrrA << ', *ptrrB er = ' << * ptrrB << std::endl;
bytte rundt ( & ptrrA, & ptrrB ) ;
std::cout << 'Efter swap: *ptrrA er = ' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
Vend tilbage 0 ;
}
Først bygger vi swap-funktionen og sender begge pointere som funktionsargumentet. I swap-funktionen tager vi 'temp'-markøren og sender værdien af 'pointer1' i 'temp' i nogen tid. Derefter overfører vi værdien af 'pointer2' til 'pointer1'. Til sidst sender vi værdien af 'temp'-markøren til 'pointer2'.
I hovedfunktionen har vi brug for to pointere, som vi videregiver eller tilsidesætter i 'swap'-funktionen. Vi videregiver adresserne på variabler til de givne pointere. Derefter vises markørens værdi før og efter udskiftning af markøren.
Outputtet af denne kode er vedhæftet i følgende:
Som vi kan se, er markørens værdier byttet med succes ved hjælp af en dobbelt pointer i C++.
Konklusion
Vi konkluderede, at pointer to pointer altid gemmer hukommelsesadressen for enhver pointer i C++. Vi kan bruge den dobbelte markør til midlertidigt at bruge hukommelsesplaceringen for enhver markør til enhver tid. Dette er en meget effektiv måde at manipulere hukommelsesadressen indirekte og nærme sig dataene.