Šis straipsnis yra apie žymiklio į žymeklį koncepciją C++. Rodyklė nukreipia arba išsaugo kito žymeklio adresą ir leidžia manipuliuoti pačiais rodyklėmis. Naudodamiesi šia koncepcija, galime lengvai pakeisti žymeklį iš kitos atminties vietos. Dvigubos rodyklės yra naudingos dinamiškai paskirstytoje atmintyje arba kelių dimensijų masyvuose, kad būtų galima manipuliuoti masyvo elementais. Aptarsime šį rodyklės veikimą ir naudojimą C++ su tinkamais pavyzdžiais.
1 scenarijus: žymeklio atvaizdavimas atmintyje
Pagal šį scenarijų dvigubo žymeklio deklaravimas yra panašus į žymeklio deklaraciją su papildoma žvaigždute (*) prieš žymeklio pavadinimą. Mes galime lengvai atvaizduoti dvigubo žymeklio atminties vietą C++. Rodyklės į žymeklį kodo fragmentas pateikiamas taip:
#include
naudojant vardų erdvę std;
tarp pagrindinis ( )
{
int skaitmuo = penkiasdešimt ;
tarpt * ptrr;
ptrr = & skaitmenų;
tarpt ** ptrr1;
ptrr1 = & ptrr;
cout << Rodyklės atminties adresas yra: \n “ ;
cout << 'ptrr (rodiklis): ' << ptrr << “ \n “ ;
cout << '*ptrr1 (dvigubas žymeklis): ' <<* ptrr1 << “ \n “ ;
cout << ' Rodyklėje saugoma vertė yra tokia: \n “ ;
cout << '*ptrr =' <<* ptrr << endl;
cout << '**ptrr1 (rodyklė į žymeklį) = ' <<** ptrr1 << endl;
grąžinti 0 ;
}
Pagrindinėje funkcijoje paimame kintamąjį, kurio atminties adresą reikia išsaugoti rodyklėje. Dabar inicijuojame „skaitmenų“ kintamąjį. Po to paskelbiame „ptrr“ rodyklę, kuri saugo „skaitmenų“ atminties adresą. Dabar paskelbiame dvigubą žymeklį, kurio pavadinimas yra „**ptrr1“, kuris saugo „*ptrr“ žymeklio adresą. Kodo pabaigoje konsolės ekrane rodome rodyklės ir dvigubo žymeklio atmintį ir reikšmę. Šio kodo išvestis paminėta toliau:
Rodyklės „ptrr“ atminties adresas yra „0x6ffe04“, o rodyklė „*ptrr1“ taip pat saugo „ptrr“ rodyklės atminties adresą. Žymeklio viduje saugoma reikšmė yra „50“. Iš esmės dvigubos žymeklio adresas visada yra toks pat kaip ir rodyklės atminties adresas.
2 scenarijus: žymeklis kaip funkcijos parametras
Šiame scenarijuje išmoksime perduoti dvigubą žymeklį bet kurioje funkcijoje kaip parametrą, kad būtų galima atlikti laikiną atminties paskirstymą bet kuriame kintamajame. Funkcijos parametro su dvigubu žymekliu kodo fragmentas paminėtas toliau:
#include
negalioja getMemoryAddress ( tarpt ** double_ptr ) {
tu oras = 200 ;
* double_ptr = & temp;
}
tarp pagrindinis ( ) {
tarpt * ptr_1;
tarpt ** double_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( double_ptr ) ;
std::cout << '**double_ptr reikšmė yra: ' << ** double_ptr << std::endl;
grąžinti 0 ;
}
Čia sužinosime, kaip žymeklio koncepcija veikia C++. Nepamirškite, kad programoje nurodyta, kad vienas žymeklis veiktų su dvigubu žymekliu. Taigi, mes sukuriame funkciją „getMemoryAddress“. Šią funkciją suprojektuojame taip, kad kai perduodame parametrą, ji automatiškai gautų dvigubo žymeklio atminties adresą.
Funkcijoje paimame kintamąjį „tempp“ ir dvigubą žymeklį „**double_ptr“. Nurodyto kintamojo adresą, kuris yra „tempp“, perduodame dvigubam žymekliui, o dvigubo rodyklės reikšmes kaip funkcijos argumentą. Programa rodo pagrindinės funkcijos kodo rezultatą konsolės ekrane, todėl visi pagrindinėje funkcijoje esantys dalykai yra vykdomi. Pagrindinėje funkcijoje „ptr_1“ ir dvigubą žymeklį laikome „double_ptr“. Rodyklės adresą perduodame dvigubam žymekliui.
Dabar perduodame dvigubo žymeklio kintamąjį nepaisymo funkcijoje ir nukreipiame žymeklį į rodyklės kintamąjį „cout“ išvesties srauto teiginyje, kad parodytume dvigubo žymeklio rezultatą.
Kai kompiliatorius pasiekia nepaisymo funkciją, kompiliatoriaus tikrintuvas, kuriame ši funkcija yra apibrėžta, vykdo kodą funkcijos viduje ir grąžina rezultatą į pagrindinę funkciją.
Šio kodo išvestis pridedama taip:
Rezultatas: dvigubo žymeklio reikšmė yra 200.
3 scenarijus: 2D masyvo naudojimas su žymekliu
Šiame pavyzdyje nagrinėsime 2D masyvą, turintį dvigubą žymeklį. Paimame masyvą ir žymeklyje perduodame masyvo adresą. Visas šio scenarijaus kodas pateikiamas taip:
tarp pagrindinis ( ) {const int eilutės = 3 ;
const int cols = 2 ;
tarpt ** matrica = naujas tarpt * [ eilučių ] ;
dėl ( int i = 0 ; i < eilutės; ++i ) {
matrica [ i ] = naujas tarpt [ sk ] ;
}
dėl ( int i = 0 ; i < eilutės; ++i ) {
dėl ( int j = 0 ; j < stulpeliai; ++j ) {
matrica [ i ] [ j ] = i * kableliai + j;
}
}
dėl ( int i = 0 ; i < eilutės; ++i ) {
dėl ( int j = 0 ; j < stulpeliai; ++j ) {
cout << matrica [ i ] [ j ] << ' ' ;
}
cout << endl;
}
dėl ( int i = 0 ; i < eilutės; ++i ) {
Ištrinti [ ] matrica [ i ] ;
}
Ištrinti [ ] matrica;
grąžinti 0 ;
}
Kaip visi žinome, 2D masyve turime daug eilučių ir kelių stulpelių. Pagrindinėje funkcijoje inicijuojame eilutes ir stulpelius, kuriuose yra „const int“. Po to kiekvienoje eilutėje paskirstome atminties vietą eilutėms ir atminties vietą stulpeliams. Perduodame eilučių skaičiaus reikšmę kaip matricos dvigubą žymeklį kaip „** matrica“. Šiame dvigubame žymeklyje eilučių skaičiaus ciklas vykdomas arba teisingas. Tada vykdoma kita vidinė kilpa, kol sąlyga tampa klaidinga.
Po atminties paskirstymo masyve vėl priskiriame reikšmę: išorinę kilpą eilėms ir vidinę 2D masyvo stulpelius. Vidinėje kilpoje eilučių ir stulpelių reikšmė priskiriama dvigubam žymekliui ir atlieka reikiamą aritmetinę operaciją. Rodome 2D masyvo reikšmes, pvz., atmintyje priskirtų eilučių ir stulpelių skaičių. Eilučių ir stulpelių skaičius visada nurodo dvigubą žymeklį, kuriame saugomos eilučių ir stulpelių reikšmės. Galų gale mes išvalome atmintį ir atimame šį masyvą iš atminties C++.
2D masyvo su dvigubu žymekliu išvestis pridedama taip:
4 scenarijus: Rodyklės keitimas naudojant žymeklį į žymeklį
Čia sužinosime, kaip sukeisti žymeklius C++, deklaruojant dvigubą žymeklį. Šio scenarijaus kodo fragmentas pridedamas taip:
#includenegaliojantis apsikeitimas ( tarpt ** ptrr_1, tu ** ptrr_2 ) {
tarpt * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
tarp pagrindinis ( ) {
int x = penkiolika , y = 25 ;
tarpt * ptrrA = & x, * ptrrB = & ir;
std::cout << 'Prieš keičiant: *ptrrA yra =' << * ptrrA << ', *ptrrB yra = ' << * ptrrB << std::endl;
apsikeisti ( & ptrrA, & ptrrB ) ;
std::cout << 'Po swap: *ptrrA is = ' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
grąžinti 0 ;
}
Pirmiausia sukuriame apsikeitimo funkciją, perduodame abi nuorodas kaip funkcijos argumentą. Apsikeitimo funkcijoje paimame „temp“ žymeklį ir kurį laiką perduodame „pointer1“ reikšmę „temp“. Tada „pointer2“ reikšmę perduodame „pointer1“. Galų gale mes perduodame „temp“ rodyklės reikšmę „pointer2“.
Pagrindinėje funkcijoje mums reikia dviejų rodyklių, kurias perduodame arba nepaisome funkcijoje „swap“. Pateiktoms rodyklėms perduodame kintamųjų adresus. Tada rodoma žymeklio reikšmė prieš ir po žymeklio pakeitimo.
Šio kodo išvestis pridedama taip:
Kaip matome, žymeklio reikšmės sėkmingai sukeičiamos naudojant dvigubą žymeklį C++.
Išvada
Padarėme išvadą, kad rodyklė į rodyklę visada išsaugo bet kurio C++ žymeklio atminties adresą. Galime naudoti dvigubą žymeklį, kad bet kuriuo metu laikinai panaudotume bet kurios žymeklio atminties vietą. Tai labai efektyvus būdas netiesiogiai manipuliuoti atminties adresu ir priartėti prie duomenų.