Tämä artikkeli käsittelee osoittimesta osoittimeen -konseptia C++:ssa. Osoitin osoittaa tai tallentaa toisen osoittimen osoitteen ja mahdollistaa itse osoittimien manipuloinnin. Tämän konseptin avulla voimme helposti muokata osoitinta toisesta muistin paikasta. Kaksoisosoittimet ovat hyödyllisiä dynaamisesti varatuissa muistissa tai moniulotteisissa taulukoissa taulukon elementtien käsittelemiseksi. Keskustelemme tästä osoittimesta osoittimen toiminnasta ja käytöstä C++:ssa oikeilla esimerkeillä.
Skenaario 1: Osoittimen esitys muistista osoittimeen
Tässä skenaariossa kaksoisosoittimen ilmoittaminen on samanlaista kuin osoittimen määrittely, jossa on ylimääräinen tähti (*) ennen osoittimen nimeä. Voimme helposti esittää kaksoisosoittimen muistipaikan C++:ssa. Osoittimesta osoittimeen koodinpätkä annetaan seuraavassa:
#include
käyttäen nimiavaruutta std;
int main ( )
{
int numero = viisikymmentä ;
int * ptrr;
ptrr = & numero;
int ** ptrr1;
ptrr1 = & ptrr;
cout << 'Osoittimen muistin osoite on: \n ' ;
cout << 'ptrr (osoitin): ' << ptrr << ' \n ' ;
cout << '*ptrr1 (kaksoisosoitin): ' <<* ptrr1 << ' \n ' ;
cout << ' Osoittimeen tallennettu arvo on: \n ' ;
cout << '*ptrr =' <<* ptrr << endl;
cout << '**ptrr1 (osoitin osoittimeen) = ' <<** ptrr1 << endl;
palata 0 ;
}
Pääfunktiossa otamme muuttujan, jonka muistiosoite on tallennettava osoittimeen. Nyt alustamme 'digitaalisen' muuttujan. Sen jälkeen julistamme 'ptrr'-osoittimen, joka tallentaa 'digitaalisen' muistiosoitteen. Nyt julistamme kaksoisosoittimen, jonka nimi on “**ptrr1”, joka tallentaa “*ptrr”-osoittimen osoitteen. Koodin lopussa näytämme osoittimen ja kaksoisosoittimen muistin ja arvon konsolin näytöllä. Tämän koodin tulos mainitaan seuraavassa:
'ptrr'-osoittimen muistiosoite on '0x6ffe04', ja '*ptrr1'-osoitin tallentaa myös 'ptrr'-osoittimen muistiosoitteen. Osoittimen sisään tallennettu arvo on '50'. Periaatteessa kaksoisosoittimen osoite on aina sama kuin osoittimen muistiosoite.
Skenaario 2: Osoittimeen toimintoparametri
Tässä skenaariossa opimme välittämään kaksoisosoitin missä tahansa funktiossa parametrina väliaikaisen muistin varauksen suorittamiseksi missä tahansa muuttujassa. Kaksoisosoittimella varustetun funktioparametrin koodinpätkä mainitaan seuraavassa:
#include
void getMemoryAddress ( int ** double_ptr ) {
sinä sää = 200 ;
* double_ptr = & lämpötila;
}
int main ( ) {
int * ptr_1;
int ** double_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( double_ptr ) ;
std::cout << '**double_ptr:n arvo on:' << ** double_ptr << std::endl;
palata 0 ;
}
Täällä opimme kuinka osoitin osoittimeen -konsepti toimii C++:ssa. Muista, että yksi osoitin on ilmoitettu ohjelmassa toimimaan kaksoisosoittimen kanssa. Joten rakennamme 'getMemoryAddress' -toiminnon. Suunnittelemme tämän funktion niin, että kun ohitamme parametrin, se saa automaattisesti kaksoisosoittimen muistiosoitteen.
Funktiossa otamme muuttujan 'tempp' ja kaksoisosoittimen '**double_ptr'. Välitämme määritetyn muuttujan osoitteen, joka on 'tempp' kaksoisosoittimelle ja kaksoisosoittimen arvot funktion argumenttina. Ohjelma näyttää päätoimintokoodin tuloksen konsolin näytöllä, joten kaikki päätoiminnossa olevat asiat ovat suoritettavissa. Otamme 'ptr_1'-osoittimen ja kaksoisosoittimen nimellä 'double_ptr' pääfunktiossa. Välitämme osoittimen osoitteen kaksoisosoittimelle.
Nyt välitämme kaksoisosoittimen muuttujan ohitusfunktiossa ja siirrämme osoittimen osoitinmuuttujaan 'cout'-lähtövirtalauseessa näyttääksesi kaksoisosoittimen tuloksen.
Kun kääntäjä saavuttaa ohitusfunktion, kääntäjätarkistus, jossa tämä funktio on määritetty, suorittaa funktion sisällä olevan koodin ja palauttaa tuloksen pääfunktiolle.
Tämän koodin tulos on liitetty seuraavaan:
Tulos: Kaksoisosoittimen arvo on 200.
Skenaario 3: 2D-taulukon käyttäminen osoittimesta osoittimeen
Tässä esimerkissä käsittelemme 2D-taulukkoa, jossa on kaksoisosoitin. Otamme taulukon ja välitämme taulukon osoitteen osoittimeen. Tämän skenaarion täydellinen koodi toimitetaan seuraavasti:
int main ( ) {const int rivit = 3 ;
const int sarakkeet = 2 ;
int ** matriisi = uusi int * [ rivit ] ;
varten ( int i = 0 ; i < rivit; ++i ) {
matriisi [ i ] = uusi int [ sarakkeet ] ;
}
varten ( int i = 0 ; i < rivit; ++i ) {
varten ( int j = 0 ; j < sarakkeet; ++j ) {
matriisi [ i ] [ j ] = i * sarakkeet + j;
}
}
varten ( int i = 0 ; i < rivit; ++i ) {
varten ( int j = 0 ; j < sarakkeet; ++j ) {
cout << matriisi [ i ] [ j ] << ' ' ;
}
cout << endl;
}
varten ( int i = 0 ; i < rivit; ++i ) {
poistaa [ ] matriisi [ i ] ;
}
poistaa [ ] matriisi;
palata 0 ;
}
Kuten me kaikki tiedämme, meillä on monia rivejä ja useita sarakkeita 2D-taulukossa. Pääfunktiossa alustamme rivit ja sarakkeet, joissa on 'const int'. Tämän jälkeen varaamme jokaiselle riville muistitilaa riveille ja muistitilaa sarakkeille. Välitämme rivien lukumäärän arvon osoittimena matriisin kaksoisosoitin muodossa '**matriisi'. Tässä kaksoisosoittimessa rivien lukumäärän silmukka suoritetaan tai tosi. Sitten suoritetaan toinen sisäinen silmukka, kunnes ehto muuttuu epätosi.
Muistin varauksen jälkeen annamme taulukossa uudelleen arvon: ulomman silmukan riveille ja sisemmän silmukan 2D-taulukon sarakkeille. Sisäsilmukassa rivien ja sarakkeiden arvo määritetään kaksoisosoittimelle ja se suorittaa vaaditun aritmeettisen toiminnon. Näytämme 2D-taulukon arvot, kuten muistiin varattujen rivien ja sarakkeiden lukumäärän. Rivien ja sarakkeiden määrä osoittaa aina kaksoisosoitinta, joka tallentaa rivit ja sarakearvot. Lopulta tyhjennämme muistin ja poistamme tämän taulukon C++:n muistista.
2D-taulukon tulos kaksoisosoittimella on liitetty seuraavaan:
Skenaario 4: Osoittimien vaihtaminen osoittimella osoittimeksi
Täällä opimme kuinka osoittimet vaihdetaan C++:ssa ilmoittamalla kaksoisosoitin. Tämän skenaarion koodinpätkä on liitteenä seuraavassa:
#includemitätön vaihto ( int ** ptrr_1, sinä ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int main ( ) {
int x = viisitoista , y = 25 ;
int * ptrrA = & x, * ptrrB = & ja;
std::cout << 'Ennen vaihtoa: *ptrrA on = ' << * ptrrA << ', *ptrrB on = ' << * ptrrB << std::endl;
vaihtaa ( & ptrrA, & ptrrB ) ;
std::cout << 'Vaihdon jälkeen: *ptrrA is = ' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
palata 0 ;
}
Ensin rakennetaan swap-funktio ja välitetään molemmat osoittimet funktion argumenttina. Swap-funktiossa otamme 'temp'-osoittimen ja välitämme 'pointer1'-arvon 'temp'-kentässä jonkin aikaa. Sitten välitämme arvon 'osoitin2' arvolle 'osoitin1'. Lopulta välitämme 'temp'-osoittimen arvon 'osoitin2:lle'.
Päätoiminnossa tarvitsemme kaksi osoitinta, jotka ohitamme tai ohitamme 'swap'-toiminnossa. Välitämme muuttujien osoitteet annetuille osoittimille. Sitten osoittimen arvo ennen osoittimen vaihtamista ja sen jälkeen näytetään.
Tämän koodin tulos on liitetty seuraavaan:
Kuten näemme, osoittimen arvot vaihdetaan onnistuneesti käyttämällä kaksoisosoitinta C++:ssa.
Johtopäätös
Päätimme, että osoitin osoittimeen tallentaa aina minkä tahansa osoittimen muistiosoitteen C++:ssa. Voimme käyttää kaksoisosoitinta tilapäisesti käyttää minkä tahansa osoittimen muistipaikkaa milloin tahansa. Tämä on erittäin tehokas tapa manipuloida muistiosoitetta epäsuorasti ja lähestyä tietoja.