Šis raksts ir par rādītāja uz rādītāja jēdzienu C++. Rādītājs norāda vai saglabā cita rādītāja adresi un ļauj manipulēt ar pašiem rādītājiem. Izmantojot šo koncepciju, mēs varam viegli modificēt rādītāju no citas vietas atmiņā. Divkāršās norādes ir noderīgas dinamiski piešķirtajā atmiņā vai daudzdimensiju masīvos, lai manipulētu ar masīva elementiem. Mēs apspriedīsim šo rādītāju par rādītāja darbību un lietošanu programmā C++ ar atbilstošiem piemēriem.
1. scenārijs: Rādītāja attēlojums atmiņā
Šajā scenārijā dubultā rādītāja deklarēšana ir līdzīga rādītāja deklarācijai ar papildu zvaigznīti (*) pirms rādītāja nosaukuma. Mēs varam viegli attēlot dubultā rādītāja atmiņas vietu C++. Rādītāja koda fragments ir norādīts tālāk:
#include
izmantojot namespace std;
int galvenais ( )
{
int cipars = piecdesmit ;
starpt * ptrr;
ptrr = & cipars;
starpt ** ptrr1;
ptrr1 = & ptrr;
cout << 'Rādītāja atmiņas adrese ir: \n ' ;
cout << 'ptrr (rādītājs): ' << ptrr << ' \n ' ;
cout << '*ptrr1 (dubultā rādītājs):' <<* ptrr1 << ' \n ' ;
cout << ' Rādītāja saglabātā vērtība ir: \n ' ;
cout << '*ptrr =' <<* ptrr << endl;
cout << '**ptrr1 (norādītājs uz rādītāju) = ' <<** ptrr1 << endl;
atgriezties 0 ;
}
Galvenajā funkcijā mēs ņemam mainīgo, kura atmiņas adrese ir jāsaglabā rādītājā. Tagad mēs inicializējam mainīgo “ciparu”. Pēc tam mēs deklarējam “ptrr” rādītāju, kas saglabā “ciparu” atmiņas adresi. Tagad mēs deklarējam dubulto rādītāju, kura nosaukums ir “**ptrr1”, kas saglabā rādītāja “*ptrr” adresi. Koda beigās mēs konsoles ekrānā parādām rādītāja un dubultā rādītāja atmiņu un vērtību. Šī koda izvade ir minēta šādi:
“ptrr” rādītāja atmiņas adrese ir “0x6ffe04”, un rādītājs “*ptrr1” saglabā arī “ptrr” rādītāja atmiņas adresi. Rādītāja iekšpusē saglabātā vērtība ir “50”. Būtībā dubultā rādītāja adrese vienmēr ir tāda pati kā rādītāja atmiņas adrese.
2. scenārijs: rādītājs uz rādītāju kā funkcijas parametru
Šajā scenārijā mēs iemācīsimies nodot dubulto rādītāju jebkurā funkcijā kā parametru, lai veiktu pagaidu atmiņas piešķiršanu jebkuram mainīgajam. Funkcijas parametra koda fragments ar dubulto rādītāju ir minēts tālāk:
#include
nederīgs getMemoryAddress ( starpt ** double_ptr ) {
tu laikapstākļi = 200 ;
* double_ptr = & temp;
}
int galvenais ( ) {
starpt * ptr_1;
starpt ** double_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( double_ptr ) ;
std::cout << '**double_ptr vērtība ir:' << ** double_ptr << std::endl;
atgriezties 0 ;
}
Šeit mēs uzzināsim, kā rādītāja uz rādītāja koncepcija darbojas C++. Atcerieties, ka viens rādītājs programmā ir deklarēts darbam ar dubulto rādītāju. Tātad, mēs izveidojam funkciju “getMemoryAddress”. Mēs izstrādājam šo funkciju tā, lai, nododot parametru, tā automātiski iegūtu dubultā rādītāja atmiņas adresi.
Funkcijā mēs izmantojam mainīgo “tempp” un dubulto rādītāju “**double_ptr”. Mēs nododam norādītā mainīgā adresi, kas ir “tempp”, dubultrādītājai un dubultā rādītāja vērtības kā funkcijas argumentu. Programma parāda galvenās funkcijas koda rezultātu konsoles ekrānā, tāpēc visas lietas, kas atrodas galvenajā funkcijā, ir izpildāmas. Mēs ņemam “ptr_1” rādītāju un dubulto rādītāju kā “double_ptr” galvenajā funkcijā. Nododam rādītāja adresi dubultrādītājam.
Tagad mēs nododam dubultā rādītāja mainīgo ignorēšanas funkcijā un nododam rādītāju rādītāja mainīgajam izvades straumes paziņojumā “cout”, lai parādītu dubultā rādītāja rezultātu.
Kad kompilators sasniedz ignorēšanas funkciju, kompilatora pārbaudītājs, kurā šī funkcija ir definēta, izpilda funkcijas iekšpusē esošo kodu un atgriež rezultātu galvenajai funkcijai.
Šī koda izvade ir pievienota šādi:
Rezultāts: dubultā rādītāja vērtība ir 200.
3. scenārijs: 2D masīva izmantošana ar rādītāju no rādītāja uz rādītāju
Šajā piemērā mēs aplūkosim 2D masīvu ar dubulto rādītāju. Mēs ņemam masīvu un nododam rādītājā masīva adresi. Pilns šī scenārija kods ir sniegts šādi:
int galvenais ( ) {const int rindas = 3 ;
const int cols = 2 ;
starpt ** matrica = jauns int * [ rindas ] ;
priekš ( int i = 0 ; i < rindas; ++i ) {
matrica [ i ] = jauns starpt [ kolonnas ] ;
}
priekš ( int i = 0 ; i < rindas; ++i ) {
priekš ( int j = 0 ; j < cols; ++j ) {
matrica [ i ] [ j ] = i * cols + j;
}
}
priekš ( int i = 0 ; i < rindas; ++i ) {
priekš ( int j = 0 ; j < cols; ++j ) {
cout << matrica [ i ] [ j ] << ' ' ;
}
cout << endl;
}
priekš ( int i = 0 ; i < rindas; ++i ) {
dzēst [ ] matrica [ i ] ;
}
dzēst [ ] matrica;
atgriezties 0 ;
}
Kā mēs visi zinām, mums ir daudz rindu un vairākas kolonnas 2D masīvā. Galvenajā funkcijā mēs inicializējam rindas un kolonnas, kurām ir “const int”. Pēc tam katrā rindā mēs piešķiram atmiņas vietu rindām un atmiņas vietu kolonnām. Mēs nododam rindu skaita vērtību kā rādītāju matricā dubultrādītāju kā “**matrica”. Šajā dubultā rādītājā rindu skaita cilpa tiek izpildīta vai patiesa. Pēc tam tiek izpildīta vēl viena iekšējā cilpa, līdz nosacījums kļūst nepatiess.
Pēc atmiņas piešķiršanas mēs atkal piešķiram vērtību masīvā: ārējo cilpu rindām un iekšējo cilpu 2D masīva kolonnām. Iekšējā cilpā rindu un kolonnu vērtība tiek piešķirta dubultajam rādītājam un veic nepieciešamo aritmētisko darbību. Mēs parādām 2D masīva vērtības, piemēram, atmiņā piešķirto rindu un kolonnu skaitu. Rindu un kolonnu skaits vienmēr norāda uz dubulto rādītāju, kas saglabā rindu un kolonnu vērtības. Beigās mēs iztīrām atmiņu un atdalām šo masīvu no C++ atmiņas.
2D masīva izvade ar dubulto rādītāju ir pievienota šādi:
4. scenārijs: Rādītāju maiņa, izmantojot rādītāju pret rādītāju
Šeit mēs uzzināsim, kā apmainīt rādītājus programmā C++, deklarējot dubulto rādītāju. Šī scenārija koda fragments ir pievienots tālāk norādītajā veidā.
#includespēkā neesoša mijmaiņa ( starpt ** ptrr_1, tu ** ptrr_2 ) {
starpt * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int galvenais ( ) {
int x = piecpadsmit , y = 25 ;
starpt * ptrrA = & x, * ptrrB = & un;
std::cout << 'Pirms apmaiņas: *ptrrA ir =' << * ptrrA << ', *ptrrB ir = ' << * ptrrB << std::endl;
mijmaiņa ( & ptrrA, & ptrrB ) ;
std::cout << 'Pēc apmaiņas: *ptrrA ir = ' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
atgriezties 0 ;
}
Pirmkārt, mēs izveidojam mijmaiņas funkciju, nododot abus rādītājus kā funkcijas argumentu. Mijmaiņas funkcijā mēs paņemam “temp” rādītāju un kādu laiku nododam “pointer1” vērtību “temp”. Pēc tam mēs nododam “pointer2” vērtību uz “pointer1”. Beigās mēs nododam “temp” rādītāja vērtību “pointer2”.
Galvenajā funkcijā mums ir nepieciešami divi norādes, kuras mēs nododam vai ignorējam funkcijā “swap”. Mēs nododam mainīgo adreses dotajiem rādītājiem. Pēc tam tiek parādīta rādītāja vērtība pirms un pēc rādītāja maiņas.
Šī koda izvade ir pievienota šādi:
Kā redzam, rādītāja vērtības tiek veiksmīgi apmainītas, izmantojot dubulto rādītāju C++.
Secinājums
Mēs secinājām, ka rādītājs uz rādītāju vienmēr saglabā jebkura rādītāja atmiņas adresi C++. Mēs varam izmantot dubulto rādītāju, lai jebkurā brīdī īslaicīgi izmantotu jebkura rādītāja atmiņas vietu. Tas ir ļoti efektīvs veids, kā netieši manipulēt ar atmiņas adresi un piekļūt datiem.