Ta članek govori o konceptu kazalca na kazalec v C++. Kazalec na kazalec kaže ali shrani naslov drugega kazalca in omogoča manipulacijo samih kazalcev. Z uporabo tega koncepta lahko preprosto spremenimo kazalec z druge lokacije v pomnilniku. Dvojni kazalci so koristni v dinamično dodeljenem pomnilniku ali večdimenzionalnih nizih za manipulacijo elementov polja. Razpravljali bomo o delu in uporabi tega kazalca na kazalec v C++ z ustreznimi primeri.
1. scenarij: pomnilniška predstavitev kazalca na kazalec
V tem scenariju je deklaracija dvojnega kazalca podobna deklaraciji kazalca z dodatno zvezdico (*) pred imenom kazalca. V C++ lahko preprosto predstavimo pomnilniško lokacijo dvojnega kazalca. Delček kode kazalca na kazalec je podan v naslednjem:
#include
uporaba imenskega prostora std;
int main ( )
{
int digit = petdeset ;
int * ptrr;
ptrr = & številka;
int ** ptrr1;
ptrr1 = & ptrr;
cout << 'Naslov pomnilnika kazalca je: \n ' ;
cout << 'ptrr (kazalec): ' << ptrr << ' \n ' ;
cout << '*ptrr1 (dvojni kazalec): ' <<* ptrr1 << ' \n ' ;
cout << ' Vrednost, shranjena v kazalcu, je: \n ' ;
cout << '*ptrr = ' <<* ptrr << endl;
cout << '**ptrr1 (kazalec na kazalec) = ' <<** ptrr1 << endl;
vrnitev 0 ;
}
V glavni funkciji vzamemo spremenljivko, katere pomnilniški naslov je treba shraniti v kazalec. Zdaj inicializiramo spremenljivko 'cifra'. Po tem deklariramo kazalec 'ptrr', ki shrani pomnilniški naslov 'cifra'. Zdaj deklariramo dvojni kazalec, katerega ime je '**ptrr1', ki shrani naslov kazalca '*ptrr'. Na koncu kode prikažemo spomin in vrednost kazalca in dvojnega kazalca na zaslonu konzole. Izhod te kode je omenjen v naslednjem:
Pomnilniški naslov kazalca »ptrr« je »0x6ffe04«, kazalec »*ptrr1« pa shrani tudi pomnilniški naslov kazalca »ptrr«. Vrednost, ki je shranjena znotraj kazalca, je '50'. V bistvu je naslov dvojnega kazalca vedno enak pomnilniškemu naslovu kazalca.
2. scenarij: Kazalec na kazalec kot parameter funkcije
V tem scenariju se bomo naučili, kako posredovati dvojni kazalec v kateri koli funkciji kot parameter za izvedbo začasne dodelitve pomnilnika v kateri koli spremenljivki. Delček kode parametra funkcije z dvojnim kazalcem je omenjen v naslednjem:
#include
void getMemoryAddress ( int ** dvojni_ptr ) {
ti vreme = 200 ;
* dvojni_ptr = & temp;
}
int main ( ) {
int * ptr_1;
int ** dvojni_ptr;
dvojni_ptr = & ptr_1;
getMemoryAddress ( dvojni_ptr ) ;
std::cout << 'Vrednost **double_ptr je: ' << ** dvojni_ptr << std::endl;
vrnitev 0 ;
}
Tukaj se bomo naučili, kako deluje koncept kazalca na kazalec v C++. Ne pozabite, da je en kazalec v programu deklariran za delo z dvojnim kazalcem. Torej zgradimo funkcijo 'getMemoryAddress'. To funkcijo oblikujemo tako, da ko posredujemo parameter, samodejno dobi pomnilniški naslov dvojnega kazalca.
V funkciji vzamemo spremenljivko 'tempp' in dvojni kazalec '**double_ptr'. Dvojnemu kazalcu posredujemo naslov podane spremenljivke, ki je »tempp«, in vrednosti dvojnega kazalca kot argument funkcije. Program prikaže rezultat kode glavne funkcije na zaslonu konzole, tako da so vse stvari, ki so v glavni funkciji, izvršljive. Kazalec »ptr_1« in dvojni kazalec vzamemo kot »double_ptr« v glavni funkciji. Dvojnemu kazalcu posredujemo naslov kazalca.
Zdaj posredujemo spremenljivko dvojnega kazalca v funkciji preglasitve in posredujemo kazalec na spremenljivko kazalca v stavku izhodnega toka »cout«, da prikažemo rezultat dvojnega kazalca.
Ko prevajalnik doseže funkcijo preglasitve, preverjevalnik prevajalnika, kjer je ta funkcija definirana, izvede kodo znotraj funkcije in vrne rezultat glavni funkciji.
Izhod te kode je priložen v naslednjem:
Rezultat: vrednost dvojnega kazalca je 200.
3. scenarij: Uporaba 2D matrike s kazalcem na kazalec
V tem primeru bomo obravnavali 2D polje z dvojnim kazalcem. Vzamemo matriko in posredujemo naslov matrike v kazalcu. Celotna koda tega scenarija je na voljo, kot sledi:
int main ( ) {const int vrstic = 3 ;
const int cols = 2 ;
int ** matrika = nova int * [ vrstice ] ;
za ( int i = 0 ; jaz < vrstice; ++i ) {
matrica [ jaz ] = nova int [ cols ] ;
}
za ( int i = 0 ; jaz < vrstice; ++i ) {
za ( int j = 0 ; j < cols; ++j ) {
matrica [ jaz ] [ j ] = i * cols + j;
}
}
za ( int i = 0 ; jaz < vrstice; ++i ) {
za ( int j = 0 ; j < cols; ++j ) {
cout << matrica [ jaz ] [ j ] << ' ' ;
}
cout << endl;
}
za ( int i = 0 ; jaz < vrstice; ++i ) {
izbrisati [ ] matrica [ jaz ] ;
}
izbrisati [ ] matrica;
vrnitev 0 ;
}
Kot vsi vemo, imamo veliko vrstic in več stolpcev v 2D nizu. V glavni funkciji inicializiramo vrstice in stolpce, ki imajo »const int«. Nato dodelimo pomnilniški prostor za vrstice in pomnilniški prostor za stolpce vzdolž vsake vrstice. Vrednost števila vrstic posredujemo kot kazalec v dvojnem kazalcu matrike kot »**matrix«. V tem dvojnem kazalcu je zanka števila vrstic izvedena ali resnična. Nato se izvede še ena notranja zanka, dokler pogoj ne postane false.
Po dodelitvi pomnilnika znova dodelimo vrednost v matriki: zunanjo zanko za vrstice in notranjo zanko za stolpce 2D matrike. V notranji zanki je vrednost vrstic in stolpcev dodeljena dvojnemu kazalcu in izvede zahtevano aritmetično operacijo. Prikažemo vrednosti 2D polja, kot je število vrstic in stolpcev, ki so dodeljeni v pomnilniku. Število vrstic in stolpcev vedno kaže na dvojni kazalec, ki shranjuje vrednosti vrstic in stolpcev. Na koncu počistimo pomnilnik in to matriko sprostimo iz pomnilnika v C++.
Izhod matrike 2D z dvojnim kazalcem je priložen v naslednjem:
4. scenarij: Zamenjava kazalcev z uporabo kazalca na kazalec
Tukaj se bomo naučili, kako zamenjati kazalce v C++ z deklaracijo dvojnega kazalca. Delček kode tega scenarija je priložen v naslednjem:
#includevoid swap ( int ** ptrr_1, ti ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int main ( ) {
int x = petnajst , y = 25 ;
int * ptrrA = & x, * ptrrB = & in;
std::cout << 'Pred zamenjavo: *ptrrA je = ' << * ptrrA << ', *ptrrB je = ' << * ptrrB << std::endl;
zamenjava ( & ptrrA, & ptrrB ) ;
std::cout << 'Po zamenjavi: *ptrrA je = ' << * ptrrA << ', *ptrrB je= ' << * ptrrB << std::endl;
vrnitev 0 ;
}
Najprej zgradimo funkcijo zamenjave, tako da oba kazalca posredujemo kot argument funkcije. V funkciji zamenjave vzamemo kazalec »temp« in nekaj časa posredujemo vrednost »pointer1« v »temp«. Nato posredujemo vrednost “pointer2” v “pointer1”. Na koncu posredujemo vrednost kazalca “temp” na “pointer2”.
V glavni funkciji potrebujemo dva kazalca, ki ju prenesemo ali preglasimo v funkciji »swap«. Podanim kazalcem posredujemo naslove spremenljivk. Nato se prikaže vrednost kazalca pred in po zamenjavi kazalca.
Izhod te kode je priložen v naslednjem:
Kot lahko vidimo, so vrednosti kazalca uspešno zamenjane z uporabo dvojnega kazalca v C++.
Zaključek
Ugotovili smo, da kazalec na kazalec vedno shrani pomnilniški naslov katerega koli kazalca v C++. Z dvojnim kazalcem lahko kadar koli začasno uporabimo pomnilniško lokacijo katerega koli kazalca. To je zelo učinkovit način za posredno manipulacijo pomnilniškega naslova in približevanje podatkom.