See artikkel käsitleb C++ kontseptsiooni pointer to pointer. Kursor osutab või salvestab teise kursori aadressi ja võimaldab manipuleerida osutitega. Seda kontseptsiooni kasutades saame hõlpsasti muuta kursorit teisest asukohast mälus. Topeltosutajad on kasulikud dünaamiliselt eraldatud mälus või mitmemõõtmelistes massiivides, et manipuleerida massiivi elementidega. Arutame seda osutit C++-i töö ja kasutamise kohta õigete näidetega.
1. stsenaarium: kursori ja kursori vahel kuvatakse mälus
Selle stsenaariumi korral on topeltkursi deklareerimine sarnane kursori deklaratsiooniga, lisades tärni (*) enne kursori nime. Topeltosuti mäluasukohta saame hõlpsasti esitada C++ keeles. Kursori koodilõik on esitatud järgmiselt:
#include
kasutades nimeruumi std;
int main ( )
{
int number = viiskümmend ;
int * ptrr;
ptrr = & number;
int ** ptrr1;
ptrr1 = & ptrr;
cout << 'Osuti mälu aadress on: \n ' ;
cout << 'ptrr (osuti): ' << ptrr << ' \n ' ;
cout << '*ptrr1 (topeltkursor):' <<* ptrr1 << ' \n ' ;
cout << ' Kursorisse salvestatud väärtus on: \n ' ;
cout << '*ptrr =' <<* ptrr << endl;
cout << '**ptrr1 (kursor kursorile) = ' <<** ptrr1 << endl;
tagasi 0 ;
}
Põhifunktsioonis võtame muutuja, mille mäluaadress tuleb kursorisse salvestada. Nüüd initsialiseerime muutuja 'digitaalne'. Pärast seda deklareerime 'ptrr' osuti, mis salvestab 'numbrilise' mäluaadressi. Nüüd deklareerime topeltkursori, mille nimi on “**ptrr1”, mis salvestab kursori “*ptrr” aadressi. Koodi lõpus kuvame konsooliekraanil kursori ja topeltkursi mälu ja väärtuse. Selle koodi väljundit mainitakse järgmises:
Osuti 'ptrr' mäluaadress on '0x6ffe04' ja osuti '*ptrr1' salvestab ka 'ptrr' osuti mäluaadressi. Kursorisse salvestatud väärtus on '50'. Põhimõtteliselt on topeltkursi aadress alati sama, mis kursori mäluaadress.
2. stsenaarium: funktsiooni parameetrina kursor
Selle stsenaariumi puhul õpime, kuidas edastada topeltkursor mis tahes funktsioonis parameetrina, et teostada ajutine mälu eraldamine mis tahes muutujas. Topeltkursoriga funktsiooniparameetri koodilõik on mainitud järgmises:
#include
tühine getMemoryAddress ( int ** double_ptr ) {
sa ilm = 200 ;
* double_ptr = & temp;
}
int main ( ) {
int * ptr_1;
int ** double_ptr;
double_ptr = & ptr_1;
hankige mäluaadress ( double_ptr ) ;
std::cout << '**double_ptr väärtus on:' << ** double_ptr << std::endl;
tagasi 0 ;
}
Siit õpime, kuidas kursori kontseptsioon C++-s töötab. Pidage meeles, et üks kursor on programmis deklareeritud töötama topeltkursoriga. Niisiis loome funktsiooni 'getMemoryAddress'. Me kujundame selle funktsiooni nii, et parameetri edastamisel saab see automaatselt topeltkursi mäluaadressi.
Funktsioonis võtame muutuja tempp ja topeltkursori '**double_ptr'. Anname topeltkursorile edasi määratud muutuja aadressi, milleks on “tempp”, ja topeltkursi väärtused funktsiooni argumendina. Programm kuvab konsooli ekraanil põhifunktsiooni koodi tulemuse, seega on kõik põhifunktsioonis olevad asjad käivitatavad. Me võtame põhifunktsioonis kursori 'ptr_1' ja topeltkursori kui 'double_ptr'. Edastame kursori aadressi topeltkursorile.
Nüüd edastame topeltkursori muutuja alistamise funktsioonis ja suuname kursori kursori muutujale väljundvoo lauses 'cout', et näidata topeltkursi tulemust.
Kui kompilaator jõuab alistamise funktsioonini, käivitab kompilaatori kontrollija, kus see funktsioon on määratletud, funktsiooni sees oleva koodi ja tagastab tulemuse põhifunktsioonile.
Selle koodi väljund on lisatud järgmisele:
Tulemus: topeltkursi väärtus on 200.
3. stsenaarium: 2D-massiivi kasutamine koos kursori ja kursori vahel
Selles näites käsitleme 2D-massiivi, millel on topeltkursor. Võtame massiivi ja anname kursorisse massiivi aadressi. Selle stsenaariumi täielik kood on esitatud järgmiselt:
int main ( ) {const int read = 3 ;
const int cols = 2 ;
int ** maatriks = uus int * [ read ] ;
jaoks ( int i = 0 ; i < read; ++i ) {
maatriks [ i ] = uus int [ veerg ] ;
}
jaoks ( int i = 0 ; i < read; ++i ) {
jaoks ( int j = 0 ; j < cols; ++j ) {
maatriks [ i ] [ j ] = i * cols + j;
}
}
jaoks ( int i = 0 ; i < read; ++i ) {
jaoks ( int j = 0 ; j < cols; ++j ) {
cout << maatriks [ i ] [ j ] << ' ' ;
}
cout << endl;
}
jaoks ( int i = 0 ; i < read; ++i ) {
kustutada [ ] maatriks [ i ] ;
}
kustutada [ ] maatriks;
tagasi 0 ;
}
Nagu me kõik teame, on meil 2D-massiivis palju ridu ja mitu veergu. Põhifunktsioonis initsialiseerime read ja veerud, millel on 'const int'. Pärast seda eraldame igale reale mäluruumi ridade jaoks ja mäluruumi veergude jaoks. Edastame ridade arvu väärtuse maatriksi topeltkursorina kui “**maatriksit”. Selles topeltkursoris täidetakse ridade arvu silmus või on tõene. Seejärel käivitatakse veel üks sisemine tsükkel, kuni tingimus muutub vääraks.
Pärast mälu eraldamist omistame massiivi uuesti väärtuse: 2D massiivi ridade jaoks on välimine tsükkel ja veergude jaoks sisemine tsükkel. Sisemises tsüklis määratakse ridade ja veergude väärtus topeltkursorile ja see sooritab vajaliku aritmeetilise toimingu. Kuvame 2D-massiivi väärtused, näiteks mällu eraldatud ridade ja veergude arvu. Ridade ja veergude arv osutab alati topeltkursile, mis salvestab read ja veeru väärtused. Lõpuks tühjendame mälu ja eraldame selle massiivi C++ mälust.
Topeltkursoriga 2D-massiivi väljund on lisatud järgmiselt:
4. stsenaarium: osutite vahetamine kursori abil kursori vastu
Siin õpime, kuidas vahetada osutajaid C++-s, deklareerides topeltkursori. Selle stsenaariumi koodilõik on lisatud järgmiselt.
#includetühine vahetus ( int ** ptrr_1, sina ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int main ( ) {
int x = viisteist , y = 25 ;
int * ptrrA = & x, * ptrrB = & ja;
std::cout << 'Enne vahetamist: *ptrrA on =' << * ptrrA << ', *ptrrB on = ' << * ptrrB << std::endl;
vahetus ( & ptrrA, & ptrrB ) ;
std::cout << 'Pärast vahetust: *ptrrA on = ' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
tagasi 0 ;
}
Esiteks koostame vahetusfunktsiooni, edastades mõlemad osuti funktsiooni argumendina. Vahetusfunktsioonis võtame 'temp' kursori ja edastame 'pointer1' väärtuse mõnda aega 'temp'. Seejärel edastame 'pointer2' väärtuse väärtusele 'pointer1'. Lõpuks edastame 'temp' osuti väärtuse 'pointer2'.
Põhifunktsioonis vajame kahte osutit, mida me funktsioonis 'vahetus' edastame või alistame. Anname antud osutitele edasi muutujate aadressid. Seejärel kuvatakse kursori väärtus enne ja pärast kursori vahetamist.
Selle koodi väljund on lisatud järgmisele:
Nagu näeme, vahetatakse kursori väärtusi edukalt topeltkursori abil C++ keeles.
Järeldus
Jõudsime järeldusele, et kursor kursorile salvestab alati suvalise C++-s oleva kursori mäluaadressi. Topeltkursori abil saame ajutiselt kasutada mis tahes kursori mäluasukohta igal hetkel. See on väga tõhus viis mäluaadressi kaudseks manipuleerimiseks ja andmetele lähenemiseks.