Ez a cikk a mutató-mutató fogalmáról szól a C++ nyelvben. A mutató a mutatóra mutat, vagy tárolja egy másik mutató címét, és lehetővé teszi maguknak a mutatóknak a kezelését. Ezzel a koncepcióval könnyen módosíthatunk egy mutatót a memória egy másik helyéről. A kettős mutatók előnyösek a dinamikusan lefoglalt memóriában vagy a többdimenziós tömbökben a tömb elemeinek manipulálására. Megbeszéljük ezt a mutatót a mutató működésére és használatára a C++ nyelven megfelelő példákkal.
1. forgatókönyv: A mutató és a mutató közötti memóriaábrázolás
Ebben a forgatókönyvben a kettős mutató deklarálása hasonló a mutató deklarációjához, a mutató neve előtt egy további csillaggal (*). Egy dupla mutató memóriahelyét egyszerűen le tudjuk ábrázolni C++ nyelven. A pointer to point kódrészlete a következő:
#include
névtér használata std;
int fő ( )
{
int számjegy = ötven ;
int * ptrr;
ptrr = & számjegy;
int ** ptrr1;
ptrr1 = & ptrr;
cout << 'A mutató memória címe: \n ' ;
cout << 'ptrr (mutató): ' << ptrr << ' \n ' ;
cout << '*ptrr1 (dupla mutató): ' <<* ptrr1 << ' \n ' ;
cout << ' A mutatóban tárolt érték a következő: \n ' ;
cout << '*ptrr = ' <<* ptrr << endl;
cout << '**ptrr1 (mutató a mutatóhoz) = ' <<** ptrr1 << endl;
Visszatérés 0 ;
}
A fő függvényben veszünk egy változót, amelynek memóriacímét egy pointerben kell tárolni. Most inicializáljuk a „digit” változót. Ezt követően deklaráljuk a „ptrr” mutatót, amely a „digit” memóriacímet tárolja. Most deklaráljuk a „**ptrr1” nevű kettős mutatót, amely a „*ptrr” mutató címét tárolja. A kód végén megjelenítjük a mutató és a dupla mutató memóriáját és értékét a konzol képernyőjén. Ennek a kódnak a kimenetét a következők említik:
A „ptrr” mutató memóriacíme „0x6ffe04”, a „*ptrr1” mutató pedig a „ptrr” mutató memóriacímét is tárolja. A mutató belsejében tárolt érték „50”. Alapvetően a kettős mutató címe mindig megegyezik a mutató memóriacímével.
2. forgatókönyv: A mutató a mutatóra, mint funkcióparaméter
Ebben a forgatókönyvben megtanuljuk, hogyan adjuk át a kettős mutatót bármely függvényben paraméterként az ideiglenes memóriafoglalás végrehajtásához bármely változóban. A függvényparaméter duplamutatós kódrészletét a következőkben említjük:
#include
érvénytelen getMemoryAddress ( int ** double_ptr ) {
te időjárás = 200 ;
* double_ptr = & hőmérséklet;
}
int fő ( ) {
int * ptr_1;
int ** double_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( double_ptr ) ;
std::cout << 'A **double_ptr értéke: ' << ** double_ptr << std::endl;
Visszatérés 0 ;
}
Itt megtudjuk, hogyan működik a pointer to pointer koncepció C++ nyelven. Ne feledje, hogy egy mutató a programban úgy van deklarálva, hogy dupla mutatóval működjön. Tehát felépítjük a „getMemoryAddress” függvényt. Ezt a függvényt úgy terveztük meg, hogy amikor átadjuk a paramétert, automatikusan megkapja a dupla mutató memóriacímét.
A függvényben a „tempp” változót és a „**double_ptr” kettős mutatót vesszük. A megadott változó címét, ami „tempp”, átadjuk a dupla mutatónak, a duplamutató értékeit pedig a függvény argumentumaként. A program megjeleníti a fő funkciókód eredményét a konzol képernyőjén, így minden, ami a fő függvényben van, végrehajtható. A „ptr_1” mutatót és a dupla mutatót „double_ptr”-nek vesszük a fő függvényben. A mutató címét átadjuk a dupla mutatónak.
Most átadjuk a kettős mutató változót a felülírási függvényben, és átadjuk a mutatót a mutató változónak a „cout” kimeneti folyam utasításban, hogy megjelenítsük a dupla mutató eredményét.
Amikor a fordító eléri a felülírási függvényt, a fordítóellenőrző, ahol ez a függvény definiálva van, végrehajtja a függvényen belüli kódot, és visszaadja az eredményt a fő függvénynek.
Ennek a kódnak a kimenete az alábbiakban található:
Eredmény: A duplamutató értéke 200.
3. forgatókönyv: A 2D tömb használata a Pointer to Point funkcióval
Ebben a példában egy dupla mutatót tartalmazó 2D tömböt fogunk kezelni. Vegyünk egy tömböt, és átadjuk egy tömb címét a mutatóban. Ennek a forgatókönyvnek a teljes kódja a következő:
int fő ( ) {const int sorok = 3 ;
const int cols = 2 ;
int ** mátrix = új int * [ sorokat ] ;
számára ( int i = 0 ; én < sorok; ++i ) {
mátrix [ én ] = új int [ cols ] ;
}
számára ( int i = 0 ; én < sorok; ++i ) {
számára ( int j = 0 ; j < cols; ++j ) {
mátrix [ én ] [ j ] = i * cols + j;
}
}
számára ( int i = 0 ; én < sorok; ++i ) {
számára ( int j = 0 ; j < cols; ++j ) {
cout << mátrix [ én ] [ j ] << ' ' ;
}
cout << endl;
}
számára ( int i = 0 ; én < sorok; ++i ) {
töröl [ ] mátrix [ én ] ;
}
töröl [ ] mátrix;
Visszatérés 0 ;
}
Mint mindannyian tudjuk, sok sorunk és több oszlopunk van egy 2D tömbben. A fő függvényben inicializáljuk azokat a sorokat és oszlopokat, amelyeknél a „const int” van. Ezt követően soronként lefoglaljuk a memóriaterületet a soroknak és az oszlopoknak. A sorok számának értékét mutatóként adjuk át a mátrixban a duplamutatót „**mátrix”-ként. Ebben a dupla mutatóban a sorok számának ciklusa végrehajtódik vagy igaz. Ezután egy másik belső ciklus kerül végrehajtásra, amíg a feltétel hamis lesz.
A memóriafoglalás után ismét hozzárendelünk egy értéket egy tömbben: a 2D tömb soraihoz egy külső, az oszlopaihoz pedig egy belső hurkot. A belső ciklusban a sorok és oszlopok értéke hozzá van rendelve a dupla mutatóhoz, és elvégzi a szükséges aritmetikai műveletet. Megjelenítjük egy 2D tömb értékeit, például a memóriában lefoglalt sorok és oszlopok számát. A sorok és oszlopok száma mindig a sorokat és oszlopokat tároló dupla mutatóra mutat. Végül kitisztítjuk a memóriát, és leválasztjuk ezt a tömböt a memóriából C++-ban.
A 2D tömb dupla mutatóval ellátott kimenete az alábbiakban található:
4. forgatókönyv: A mutatók cseréje a mutató használatával a mutatóra
Itt megtanuljuk, hogyan cserélhetjük fel a mutatókat C++-ban a dupla mutató deklarálásával. Ennek a forgatókönyvnek a kódrészlete az alábbiakban található:
#includeérvénytelen csere ( int ** ptrr_1, te ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int fő ( ) {
int x = tizenöt , y = 25 ;
int * ptrrA = & x, * ptrrB = & és;
std::cout << 'Csere előtt: *ptrrA = ' << * ptrrA << ', *ptrrB = ' << * ptrrB << std::endl;
csere ( & ptrrA, & ptrrB ) ;
std::cout << 'Csere után: *ptrrA is = ' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
Visszatérés 0 ;
}
Először felállítjuk a swap függvényt, mindkét mutatót átadva a függvény argumentumának. A swap függvényben a „temp” mutatót vesszük, és a „pointer1” értékét a „temp”-ben egy ideig átadjuk. Ezután a „pointer2” értékét átadjuk a „pointer1”-nek. Végül átadjuk a „temp” mutató értékét a „pointer2”-nek.
A fő függvényben két mutatóra van szükségünk, amelyeket átadunk vagy felülírunk a „swap” függvényben. A változók címét átadjuk a megadott mutatóknak. Ezután megjelenik a mutató értéke a mutató felcserélése előtt és után.
Ennek a kódnak a kimenete az alábbiakban található:
Amint látjuk, a mutató értékei sikeresen felcserélődnek egy dupla mutató segítségével a C++ nyelven.
Következtetés
Arra a következtetésre jutottunk, hogy a pointer to pointer mindig tárolja a C++ bármely pointer memóriacímét. A dupla mutató segítségével bármikor ideiglenesen felhasználhatjuk bármely mutató memóriahelyét. Ez egy nagyon hatékony módszer a memóriacím közvetett manipulálására és az adatok megközelítésére.