Denne artikkelen handler om peker-til-peker-konseptet i C++. Pekeren til pekeren peker eller lagrer adressen til en annen peker og muliggjør manipulering av selve pekerne. Ved å bruke dette konseptet kan vi enkelt endre en peker fra et annet sted i minnet. Doble pekere er fordelaktige i dynamisk tildelt minne eller flerdimensjonale matriser for å manipulere elementene i en matrise. Vi vil diskutere denne pekeren til pekerarbeid og bruk i C++ med riktige eksempler.
Scenario 1: Minnerepresentasjon av peker til peker
I dette scenariet ligner erklæringen av dobbelpekeren på pekererklæringen med en ekstra stjerne (*) foran pekernavnet. Vi kan enkelt representere minneplasseringen til en dobbelpeker i C++. Kodebiten til pekeren til pekeren er gitt i følgende:
#include
bruker navneområde std;
int main ( )
{
int siffer = femti ;
int * ptrr;
ptrr = & siffer;
int ** ptrr1;
ptrr1 = & ptrr;
cout << 'Pekerminneadressen er: \n ' ;
cout << 'ptrr (peker): ' << ptrr << ' \n ' ;
cout << '*ptrr1 (dobbeltpeker): ' <<* ptrr1 << ' \n ' ;
cout << ' Verdien som lagres i pekeren er: \n ' ;
cout << '*ptrr = ' <<* ptrr << endl;
cout << '**ptrr1 (peker til peker) = ' <<** ptrr1 << endl;
komme tilbake 0 ;
}
I hovedfunksjonen tar vi en variabel hvis minneadresse må lagres i en peker. Nå initialiserer vi 'siffer'-variabelen. Etter det erklærer vi 'ptrr'-pekeren som lagrer 'siffer'-minneadressen. Nå erklærer vi dobbeltpekeren hvis navn er '**ptrr1' som lagrer adressen til '*ptrr'-pekeren. På slutten av koden viser vi minnet og verdien til pekeren og dobbelpekeren på konsollskjermen. Utgangen av denne koden er nevnt i følgende:
Minneadressen til 'ptrr'-pekeren er '0x6ffe04', og '*ptrr1'-pekeren lagrer også minneadressen til 'ptrr'-pekeren. Verdien som er lagret inne i pekeren er '50'. I utgangspunktet er adressen til dobbeltpekeren alltid den samme som minneadressen til pekeren.
Scenario 2: Peker til peker som funksjonsparameter
I dette scenariet vil vi lære hvordan du sender dobbeltpekeren i en hvilken som helst funksjon som en parameter for å utføre den midlertidige minneallokeringen i en hvilken som helst variabel. Kodebiten til funksjonsparameteren med dobbel peker er nevnt i følgende:
#include
void getMemoryAddress ( int ** double_ptr ) {
du vær = 200 ;
* double_ptr = & temp;
}
int main ( ) {
int * ptr_1;
int ** dobbel_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( double_ptr ) ;
std::cout << 'Verdien av **double_ptr er: ' << ** double_ptr << std::endl;
komme tilbake 0 ;
}
Her vil vi lære hvordan peker-til-peker-konseptet fungerer i C++. Husk at en peker er deklarert i programmet for å fungere med en dobbel peker. Så vi bygger 'getMemoryAddress' -funksjonen. Vi designer denne funksjonen slik at når vi sender parameteren, får den automatisk minneadressen til dobbelpekeren.
I funksjonen tar vi «tempp»-variabelen og «**double_ptr»-dobbeltpekeren. Vi sender adressen til den angitte variabelen som er 'tempp' til dobbelpekeren og dobbelpekerverdiene som et argument for funksjonen. Programmet viser resultatet av hovedfunksjonskoden på konsollskjermen, så alle tingene som er i hovedfunksjonen er kjørbare. Vi tar 'ptr_1'-pekeren og dobbelpekeren som 'double_ptr' i hovedfunksjonen. Vi sender adressen til pekeren til dobbeltpekeren.
Nå sender vi dobbeltpekervariabelen i overstyringsfunksjonen og sender pekeren til pekervariabelen i 'cout' utgangsstrømsetningen for å vise resultatet av dobbelpekeren.
Når kompilatoren når overstyringsfunksjonen, kjører kompilatorkontrollen der denne funksjonen er definert koden inne i funksjonen og returnerer resultatet til hovedfunksjonen.
Utdataene fra denne koden er vedlagt i følgende:
Resultat: Verdien av dobbelpekeren er 200.
Scenario 3: Bruk av 2D-arrayen med peker til peker
I dette eksemplet vil vi ta for oss en 2D-array som har en dobbel peker. Vi tar en matrise og sender adressen til en matrise i pekeren. Den fullstendige koden for dette scenariet er gitt som følger:
int main ( ) {const int rader = 3 ;
const int cols = 2 ;
int ** matrise = ny int * [ rader ] ;
til ( int i = 0 ; Jeg < rader; ++i ) {
matrise [ Jeg ] = ny int [ cols ] ;
}
til ( int i = 0 ; Jeg < rader; ++i ) {
til ( int j = 0 ; j < cols; ++j ) {
matrise [ Jeg ] [ j ] = i * cols + j;
}
}
til ( int i = 0 ; Jeg < rader; ++i ) {
til ( int j = 0 ; j < cols; ++j ) {
cout << matrise [ Jeg ] [ j ] << ' ' ;
}
cout << endl;
}
til ( int i = 0 ; Jeg < rader; ++i ) {
slette [ ] matrise [ Jeg ] ;
}
slette [ ] matrise;
komme tilbake 0 ;
}
Som vi alle vet, har vi mange rader og flere kolonner i en 2D-array. I hovedfunksjonen initialiserer vi radene og kolonnene som har 'const int'. Etter det tildeler vi minneplassen for radene og minneplassen for kolonnene langs hver rad. Vi sender verdien for antall rader som en peker i matrisens dobbelpeker som '**matrise'. I denne doble pekeren blir løkken av antall rader utført eller sann. Deretter utføres en annen indre sløyfe til tilstanden blir falsk.
Etter minnetildelingen tildeler vi en verdi i en matrise igjen: en ytre løkke for radene og en indre løkke for kolonnene i 2D-matrisen. I den indre sløyfen blir verdien av rader og kolonner tilordnet dobbeltpekeren og utfører en nødvendig aritmetisk operasjon. Vi viser verdiene til en 2D-array som antall rader og kolonner som er tildelt i minnet. Antall rader og kolonner peker alltid til dobbeltpekeren som lagrer radene og kolonneverdiene. Til slutt rydder vi minnet og tildeler denne matrisen fra minnet i C++.
Utgangen fra 2D-matrisen med en dobbel peker er festet i følgende:
Scenario 4: Bytte pekere ved å bruke peker til peker
Her vil vi lære hvordan du bytter pekere i C++ ved å erklære dobbeltpekeren. Kodebiten for dette scenariet er vedlagt i følgende:
#includeugyldig bytte ( int ** ptrr_1, du ** 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 bytte: *ptrrA er = ' << * ptrrA << ', *ptrrB er = ' << * ptrrB << std::endl;
bytte ( & ptrrA, & ptrrB ) ;
std::cout << 'Etter bytte: *ptrrA is = ' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
komme tilbake 0 ;
}
Først bygger vi swap-funksjonen, og sender begge pekerne som funksjonsargumentet. I byttefunksjonen tar vi 'temp'-pekeren og sender verdien av 'pointer1' i 'temp' i noen tid. Deretter sender vi verdien av 'peker2' til 'peker1'. Til slutt sender vi verdien av 'temp'-pekeren til 'pointer2'.
I hovedfunksjonen trenger vi to pekere som vi passerer eller overstyrer i 'bytte'-funksjonen. Vi sender adressene til variablene til de gitte pekerne. Deretter vises pekerens verdi før og etter bytte av pekeren.
Utdataene fra denne koden er vedlagt i følgende:
Som vi kan se, byttes pekerens verdier med hell ved hjelp av en dobbel peker i C++.
Konklusjon
Vi konkluderte med at pekeren til pekeren alltid lagrer minneadressen til enhver peker i C++. Vi kan bruke den doble pekeren til midlertidig å bruke minneplasseringen til en hvilken som helst peker når som helst. Dette er en veldig effektiv måte å manipulere minneadressen indirekte og nærme seg dataene.