Den här artikeln handlar om konceptet pekare till pekare i C++. Pekaren till pekaren pekar eller lagrar adressen till en annan pekare och möjliggör manipulering av själva pekarna. Med detta koncept kan vi enkelt modifiera en pekare från en annan plats i minnet. Dubbla pekare är fördelaktiga i dynamiskt allokerade minne eller flerdimensionella arrayer för att manipulera elementen i en array. Vi kommer att diskutera denna pekare till pekararbete och användning i C++ med lämpliga exempel.
Scenario 1: Minnesrepresentation av pekare till pekare
I det här scenariot liknar deklarationen av dubbelpekaren pekarens deklaration med en extra asterisk (*) före pekarens namn. Vi kan enkelt representera minnesplatsen för en dubbelpekare i C++. Kodavsnittet för pekaren till pekaren ges i följande:
#include
använder namnutrymme std;
int main ( )
{
int siffra = femtio ;
int * ptrr;
ptrr = & siffra;
int ** ptrl;
ptrr1 = & ptrr;
cout << 'Pekarminnesadressen är: \n ' ;
cout << 'ptrr (pekare): ' << ptrr << ' \n ' ;
cout << '*ptrr1 (dubbelpekare): ' <<* ptrr1 << ' \n ' ;
cout << ' Värdet som lagras i pekaren är: \n ' ;
cout << '*ptrr = ' <<* ptrr << endl;
cout << '**ptrr1 (pekare till pekare) = ' <<** ptrr1 << endl;
lämna tillbaka 0 ;
}
I huvudfunktionen tar vi en variabel vars minnesadress behöver lagras i en pekare. Nu initierar vi 'siffervariabeln'. Efter det deklarerar vi 'ptrr'-pekaren som lagrar 'siffran' minnesadress. Nu förklarar vi dubbelpekaren vars namn är '**ptrr1' som lagrar adressen till '*ptrr'-pekaren. I slutet av koden visar vi minnet och värdet för pekaren och dubbelpekaren på konsolskärmen. Utdata från denna kod nämns i följande:
Minnesadressen för 'ptrr'-pekaren är '0x6ffe04', och '*ptrr1'-pekaren lagrar också minnesadressen för 'ptrr'-pekaren. Värdet som lagras inuti pekaren är '50'. I grund och botten är adressen för dubbelpekaren alltid densamma som minnesadressen för pekaren.
Scenario 2: Pekare till pekare som funktionsparameter
I det här scenariot kommer vi att lära oss hur man skickar dubbelpekaren i valfri funktion som en parameter för att utföra den temporära minnesallokeringen i valfri variabel. Kodavsnittet för funktionsparametern med dubbelpekare nämns i följande:
#inkludera
ogiltig getMemoryAddress ( int ** dubbel_ptr ) {
du väder = 200 ;
* dubbel_ptr = & temp;
}
int main ( ) {
int * ptr_1;
int ** dubbel_ptr;
dubbel_ptr = & ptr_1;
getMemoryAddress ( dubbel_ptr ) ;
std::cout << 'Värdet på **double_ptr är: ' << ** dubbel_ptr << std::endl;
lämna tillbaka 0 ;
}
Här kommer vi att lära oss hur pekare till pekare-konceptet fungerar i C++. Kom ihåg att en pekare är deklarerad i programmet att fungera med en dubbelpekare. Så vi bygger funktionen 'getMemoryAddress'. Vi designar denna funktion så att när vi skickar parametern får den automatiskt minnesadressen för dubbelpekaren.
I funktionen tar vi variabeln 'tempp' och dubbelpekaren '**double_ptr'. Vi skickar adressen till den angivna variabeln som är 'temp' till dubbelpekaren och värdena för dubbelpekaren som ett argument för funktionen. Programmet visar resultatet av huvudfunktionskoden på konsolskärmen, så alla saker som finns i huvudfunktionen är körbara. Vi tar 'ptr_1'-pekaren och dubbelpekaren som 'double_ptr' i huvudfunktionen. Vi skickar pekarens adress till dubbelpekaren.
Nu skickar vi dubbelpekarvariabeln i åsidosättningsfunktionen och skickar pekaren till pekarvariabeln i 'cout'-utdataströmsatsen för att visa resultatet av dubbelpekaren.
När kompilatorn når åsidosättningsfunktionen, kör kompilatorkontrollen där denna funktion är definierad koden inuti funktionen och returnerar resultatet till huvudfunktionen.
Utdata från denna kod bifogas i följande:
Resultat: Dubbelpekarens värde är 200.
Scenario 3: Använda 2D-arrayen med pekare till pekare
I det här exemplet kommer vi att ta itu med en 2D-array som har en dubbelpekare. Vi tar en array och skickar adressen till en array i pekaren. Den fullständiga koden för detta scenario tillhandahålls enligt följande:
int main ( ) {const int rader = 3 ;
const int cols = 2 ;
int ** matris = ny int * [ rader ] ;
för ( int i = 0 ; i < rader; ++i ) {
matris [ i ] = ny int [ cols ] ;
}
för ( int i = 0 ; i < rader; ++i ) {
för ( int j = 0 ; j < cols; ++j ) {
matris [ i ] [ j ] = i * cols + j;
}
}
för ( int i = 0 ; i < rader; ++i ) {
för ( int j = 0 ; j < cols; ++j ) {
cout << matris [ i ] [ j ] << ' ' ;
}
cout << endl;
}
för ( int i = 0 ; i < rader; ++i ) {
radera [ ] matris [ i ] ;
}
radera [ ] matris;
lämna tillbaka 0 ;
}
Som vi alla vet har vi många rader och flera kolumner i en 2D-array. I huvudfunktionen initierar vi de rader och kolumner som har 'const int'. Därefter tilldelar vi minnesutrymmet för raderna och minnesutrymmet för kolumnerna längs varje rad. Vi skickar antalet rader som en pekare i matrisens dubbelpekare som '**matris'. I denna dubbelpekare exekveras slingan av antalet rader eller sann. Sedan exekveras ytterligare en inre loop tills villkoret blir falskt.
Efter minnesallokeringen tilldelar vi ett värde i en array igen: en yttre slinga för raderna och en inre slinga för kolumnerna i 2D-matrisen. I den inre slingan tilldelas värdet på rader och kolumner dubbelpekaren och utför en nödvändig aritmetisk operation. Vi visar värdena för en 2D-array som antalet rader och kolumner som är allokerade i minnet. Antalet rader och kolumner pekar alltid på dubbelpekaren som lagrar raderna och kolumnvärdena. Till slut rensar vi minnet och avallokerar denna array från minnet i C++.
Utdata från 2D-matrisen med en dubbelpekare bifogas i följande:
Scenario 4: Byt pekarna med hjälp av pekare till pekare
Här kommer vi att lära oss hur man byter pekare i C++ genom att deklarera dubbelpekaren. Kodavsnittet för detta scenario bifogas i följande:
#includeogiltig swap ( int ** ptrr_1, du ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int main ( ) {
int x = femton , y = 25 ;
int * ptrrA = & x, * ptrrB = & och;
std::cout << 'Innan byte: *ptrrA är = ' << * ptrrA << ', *ptrrB är = ' << * ptrrB << std::endl;
byta ( & ptrrA, & ptrrB ) ;
std::cout << 'Efter byte: *ptrrA är = ' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
lämna tillbaka 0 ;
}
Först bygger vi swap-funktionen och skickar båda pekarna som funktionsargument. I växlingsfunktionen tar vi 'temp'-pekaren och skickar värdet för 'pointer1' i 'temp' under en tid. Sedan skickar vi värdet för 'pekare2' till 'pekare1'. I slutändan skickar vi värdet på 'temp'-pekaren till 'pointer2'.
I huvudfunktionen behöver vi två pekare som vi skickar eller åsidosätter i 'byte'-funktionen. Vi skickar adresserna för variabler till de givna pekarna. Sedan visas pekarens värde före och efter byte av pekaren.
Utdata från denna kod bifogas i följande:
Som vi kan se, byts pekarens värden framgångsrikt med en dubbelpekare i C++.
Slutsats
Vi drog slutsatsen att pekaren till pekaren alltid lagrar minnesadressen för valfri pekare i C++. Vi kan använda dubbelpekaren för att tillfälligt använda minnesplatsen för valfri pekare när som helst. Detta är ett mycket effektivt sätt att manipulera minnesadressen indirekt och närma sig data.