Ta članek govori o aritmetiki kazalcev v C++. Kazalci so spremenljivke, ki shranjujejo pomnilniški naslov podatkov. Aritmetika s kazalcem je močna značilnost v svetu programskega jezika C++, ki nam omogoča, da se ukvarjamo z različnimi aritmetičnimi operacijami, pri katerih seštevanje, množenje, deljenje, povečanje, zmanjševanje in odštevanje vključujejo kazalec za razvoj novega pomnilniškega naslova v naših pomnilniških medpomnilnikih. . Aritmetika kazalca zlahka ustvari dinamično dodelitev pomnilnika. V tem članku o C++ se bomo naučili, kako na različne načine manipulirati s pomnilniškim naslovom s pomočjo kazalcev, ter podali ustrezne smernice in primere.
1. scenarij: Kazalec izvede operaciji povečanja in zmanjšanja
Tukaj se bomo naučili manipulacije s kazalcem za izdelavo različnih pomnilniških naslovov, ki imajo različne namene. Kazalci povečanja in zmanjšanja so tudi aritmetika kazalcev vzvoda, ki povečajo ali zmanjšajo naslov za faktor ena, pomnožen z velikostjo podatkovnega tipa, na katerega kažejo. Delček kode, povezan s tem scenarijem, je priložen v naslednjem:
#include
uporaba imenskega prostora std;
const int Arr_Max = 5 ;
int main ( ) {
int kje [ Arr_Max ] = { dvajset , 150 , 270 } ;
int * ptr; // izjaviti kazalec
ptr = var;
za ( int i = 0 ; jaz < Arr_Max; i++ ) {
std::cout << 'Pomnilniški naslov elementa je: [' << jaz << '] = ' ;
std::cout << ptr << endl;
cout << 'Vrednost glede na naslov je [' << jaz << '] = ' ;
cout << * ptr << endl;
std::cout << 'kazalec je bil uspešno povečan' << endl;
ptr++;
}
std::cout << 'Naslov kazalca pred dekrementom' << ptr << endl;
ptr--;
std::cout << 'Naslov kazalca po dekrementu' << ptr << endl;
vrnitev 0 ;
}
Tukaj definiramo zahtevano knjižnico v kodi na samem začetku: “
Matriko posredujemo kazalcu za dostop do naslova. Kot vsi vemo, nizi vedno vsebujejo več elementov na različnih lokacijah. Torej smo potrebovali zanko s kazalcem »pomoč« za dostop do vsakega elementa matrike. Vsakič, ko se zanka izvede, dobimo pomnilniški naslov in vrednosti za ta naslov s pomočjo kazalnega aritmetičnega operatorja prirastka »ptr++«, ki premakne pomnilniški naslov na naslednji naslov pomnilnika. Cikel izvajanja zanke je odvisen od velikosti polja. Zunaj zanke želimo vrniti kazalec na prejšnji pomnilniški naslov samo z uporabo dekrementnega kazalca »ptr- -«.
Izvedite to kodo tako, da kliknete možnost Execute>Compile & Run in dobili boste naslednji rezultat:
Upajmo, da je ta rezultat enostaven za razumevanje. Naslov pomnilnika in vrednost sta spremenjena. Premik kazalca z ene lokacije je mogoč samo iz aritmetike kazalca prirastka v C++.
Scenarij 2: Odštevanje dveh kazalcev v C++
V tem scenariju se bomo naučili odšteti dva ali več kazalcev v C++. Vse aritmetične operacije, pri katerih pride do odštevanja, so vitalni procesi, saj lahko odštejemo dva kazalca hkrati le, če in samo če imata isti podatkovni tip.
Druge operacije, kot so seštevanje, množenje in deljenje, niso možne v kazalcu, ker nimajo smisla pri naslavljanju pomnilnika. Delček kode je priložen v naslednjem:
#includeint main ( ) {
Vabi [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & Na to [ 3 ] ; // Kazalec na tretji element ( 42 )
int * ptrr2 = & Na to [ 6 ] ; // Kazalec na šesti element ( 89 )
ptrdiff_t ptrsubtract = ptrr2 - ptrr1;
std::cout << 'Razlika med temi naslovi je: ' << ptrsubtract << 'elementi' << std::endl;
vrnitev 0 ;
}
Operacija odštevanja je iskanje razlike med pomnilniškim naslovom v C++. V glavni funkciji vzamemo matriko, ki vsebuje različne vrednosti pri različnih indeksih. V matriki ima vsak indeks drugačno pomnilniško lokacijo. Razliko med dvema kazalcema lahko ugotovimo le s pomočjo aritmetike kazalca. Tukaj uporabljamo poseben tip kazalca 'ptrdiff_t', ki ga je treba uporabiti za iskanje razlik med dvema ali več kazalci v C++.
Izhod te kode je priložen v naslednjem:
Razlika med temi naslovi je v elementu vise, ki je 3.
3. scenarij: Primerjajte dva ali več kazalcev v C++
V tem scenariju se bomo naučili primerjati različne kazalce v C++ z uporabo različnih relacijskih operaterjev, kot so “==”, “<=”, “>=”, “<”, ”>”. Kazalce lahko primerjamo le, če kažejo na naslove elementov iste matrike. Ne pozabite, da lahko primerjava dveh kazalcev z različnimi vrstami povzroči nedefinirano vedenje. Delček kode, ki je povezan s primerjavo kazalcev, je omenjen v naslednjem:
#includeuporaba imenskega prostora std;
int main ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , enajst , 14 , 16 , 18 , dvajset , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
če ( ptr1 ==ptr2 )
{
std::cout << 'kazalci so enaki' << endl;
}
drugače če ( ptr3 < =ptr4 )
{
std::cout << 'ptr3 je manjši ali enak kot ptr4' << konec ;;
}
drugače
{
std::cout << 'kazalci se ne primerjajo na nobeni stopnji' << endl;
}
vrnitev 0 ;
}
Tukaj vzamemo matriko z 10 elementi. Razglasimo štiri kazalce, ki kažejo na različen indeks matrike. Po tem primerjamo te štiri kazalce pri različnih pogojih, kot je razvidno iz dane kode. V pogoju »if« preverite, ali je kazalec »ptr1« enak kazalcu »ptr2«, nato pa natisnite »kazalci so enaki«. Ko imamo več pogojev, pri katerih uporabimo pogoj »else if«, da preverimo, ali je kazalec »ptr3« manj kot enak kazalcu »ptr4«. Po vsem tem kliknite na Izvedi > Prevedi in zaženi možnost.
Izhod te kode je priložen v naslednjem:
Na zaslonu konzole prikaže veljaven pogoj in zapusti kompilacijo. Kazalec »ptr3« vsebuje vrednost, ki je manjša ali enaka kazalni vrednosti kazalca »ptr4«.
4. scenarij: Prikažite liho število z aritmetiko kazalca
Tukaj bomo videli, kako lahko dinamično dodelimo pomnilnik za niz celih števil. Delček kode, povezan s tem primerom, je podan v naslednjem:
#includeint main ( ) {
int števila [ ] = { 1 , 12 , 33 , 24 , petnajst , 776 , 71 , 18 , 29 , petdeset } ;
int * ptrr = številke;
std::cout << 'Liha števila v nizih: ' ;
za ( int i = 0 ; jaz < 10 ; ++i ) {
če ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << ' ' ;
}
ptrr++;
}
std::cout << std::endl;
vrnitev 0 ;
}
V glavni funkciji vzamemo matriko, ki vsebuje 10 elementov. Potrebujemo kazalec, ki kaže na vse elemente v matriki, da preverimo liho število v matriki. V zanki »za« preverite liho število z deljenjem trenutnega elementa matrike. Števec kazalca se poveča po preverjanju enega elementa matrike.
Po izvedbi kode se izhod prikaže na zaslonu konzole, ki je podan v naslednjem:
Na ta način lahko prikažemo liha števila z uporabo aritmetike kazalca na zaslonu konzole.
Zaključek
Tu sklepamo, da je aritmetika kazalca najučinkovitejše orodje, ki izvaja različne operacije v C++. Prepričajte se, da kazalec poveča ali zmanjša vrednost matrike, ki ima isto vrsto podatkov. Vrednosti matrike lahko primerjamo po njihovih pomnilniških naslovih s pomočjo kazalne aritmetike v programskem jeziku C++. S pomočjo kazalne aritmetike lahko enostavno prečkamo polje in upravljamo pomnilnik.