Na pokazivačima možemo izvoditi aritmetičke operacije poput zbrajanja, oduzimanja itd. Međutim, kako znamo da pokazivač sadrži adresu, rezultat aritmetičke operacije izvedene na pokazivaču također će biti pokazivač ako je drugi operand tipa cijeli broj. Kod oduzimanja pokazivača od pokazivača, rezultat će biti cjelobrojna vrijednost. Sljedeće aritmetičke operacije moguće su na pokazivaču u jeziku C:

niz i podniz

• Povećanje
• Smanjenje
• Dodatak
• Oduzimanje
• Usporedba

Povećanje pokazivača u C

Ako pokazivač povećamo za 1, pokazivač će početi pokazivati ​​na sljedeću lokaciju. Ovo se donekle razlikuje od opće aritmetike budući da će se vrijednost pokazivača povećati za veličinu tipa podataka na koji pokazivač pokazuje.

Možemo prelaziti nizom koristeći operaciju povećanja na pokazivaču koji će nastaviti pokazivati ​​na svaki element niza, izvršiti neku operaciju na njemu i ažurirati se u petlji.

Pravilo za povećanje pokazivača je dano u nastavku:

 new_address= current_address + i * size_of(data type) 

Gdje je i broj za koji se povećava pokazivač.

32-bitni

Za 32-bitnu int varijablu, ona će se povećati za 2 bajta.

64-bitni

Za 64-bitnu int varijablu, ona će se povećati za 4 bajta.

Pogledajmo primjer inkrementiranja varijable pokazivača na 64-bitnoj arhitekturi.

 #include int main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p+1; printf('After increment: Address of p variable is %u 
',p); // in our case, p will get incremented by 4 bytes. return 0; } 

Izlaz

 Address of p variable is 3214864300 After increment: Address of p variable is 3214864304 

Kretanje nizom pomoću pokazivača

 #include void main () { int arr[5] = {1, 2, 3, 4, 5}; int *p = arr; int i; printf('printing array elements...
&apos;); for(i = 0; i<5; i++) { printf('%d ',*(p+i)); } < pre> <p> <strong>Output</strong> </p> <pre> printing array elements... 1 2 3 4 5 </pre> <h2>Decrementing Pointer in C</h2> <p>Like increment, we can decrement a pointer variable. If we decrement a pointer, it will start pointing to the previous location. The formula of decrementing the pointer is given below:</p> <pre> new_address= current_address - i * size_of(data type) </pre> <h3>32-bit</h3> <p>For 32-bit int variable, it will be decremented by 2 bytes.</p> <h3>64-bit</h3> <p>For 64-bit int variable, it will be decremented by 4 bytes.</p> <p>Let&apos;s see the example of decrementing pointer variable on 64-bit OS.</p> <pre> #include void main(){ int number=50; int *p;//pointer to int p=&amp;number;//stores the address of number variable printf(&apos;Address of p variable is %u 
&apos;,p); p=p-1; printf(&apos;After decrement: Address of p variable is %u 
&apos;,p); // P will now point to the immidiate previous location. } </pre> <p> <strong>Output</strong> </p> <pre> Address of p variable is 3214864300 After decrement: Address of p variable is 3214864296 </pre> <h2>C Pointer Addition</h2> <p>We can add a value to the pointer variable. The formula of adding value to pointer is given below:</p> <pre> new_address= current_address + (number * size_of(data type)) </pre> <h3>32-bit</h3> <p>For 32-bit int variable, it will add 2 * number.</p> <h3>64-bit</h3> <p>For 64-bit int variable, it will add 4 * number.</p> <p>Let&apos;s see the example of adding value to pointer variable on 64-bit architecture.</p> <pre> #include int main(){ int number=50; int *p;//pointer to int p=&amp;number;//stores the address of number variable printf(&apos;Address of p variable is %u 
&apos;,p); p=p+3; //adding 3 to pointer variable printf(&apos;After adding 3: Address of p variable is %u 
&apos;,p); return 0; } </pre> <p> <strong>Output</strong> </p> <pre> Address of p variable is 3214864300 After adding 3: Address of p variable is 3214864312 </pre> <p>As you can see, the address of p is 3214864300. But after adding 3 with p variable, it is 3214864312, i.e., 4*3=12 increment. Since we are using 64-bit architecture, it increments 12. But if we were using 32-bit architecture, it was incrementing to 6 only, i.e., 2*3=6. As integer value occupies 2-byte memory in 32-bit OS.</p> <h2>C Pointer Subtraction</h2> <p>Like pointer addition, we can subtract a value from the pointer variable. Subtracting any number from a pointer will give an address. The formula of subtracting value from the pointer variable is given below:</p> <pre> new_address= current_address - (number * size_of(data type)) </pre> <h3>32-bit</h3> <p>For 32-bit int variable, it will subtract 2 * number.</p> <h3>64-bit</h3> <p>For 64-bit int variable, it will subtract 4 * number.</p> <p>Let&apos;s see the example of subtracting value from the pointer variable on 64-bit architecture.</p> <pre> #include int main(){ int number=50; int *p;//pointer to int p=&amp;number;//stores the address of number variable printf(&apos;Address of p variable is %u 
&apos;,p); p=p-3; //subtracting 3 from pointer variable printf(&apos;After subtracting 3: Address of p variable is %u 
&apos;,p); return 0; } </pre> <p> <strong>Output</strong> </p> <pre> Address of p variable is 3214864300 After subtracting 3: Address of p variable is 3214864288 </pre> <p>You can see after subtracting 3 from the pointer variable, it is 12 (4*3) less than the previous address value.</p> <p>However, instead of subtracting a number, we can also subtract an address from another address (pointer). This will result in a number. It will not be a simple arithmetic operation, but it will follow the following rule.</p> <p>If two pointers are of the same type,</p> <pre> Address2 - Address1 = (Subtraction of two addresses)/size of data type which pointer points </pre> <p>Consider the following example to subtract one pointer from an another.</p> <pre> #include void main () { int i = 100; int *p = &amp;i; int *temp; temp = p; p = p + 3; printf(&apos;Pointer Subtraction: %d - %d = %d&apos;,p, temp, p-temp); } </pre> <p> <strong>Output</strong> </p> <pre> Pointer Subtraction: 1030585080 - 1030585068 = 3 </pre> <h2>Illegal arithmetic with pointers</h2> <p>There are various operations which can not be performed on pointers. Since, pointer stores address hence we must ignore the operations which may lead to an illegal address, for example, addition, and multiplication. A list of such operations is given below.</p> <ul> <li>Address + Address = illegal</li> <li>Address * Address = illegal </li> <li>Address % Address = illegal</li> <li>Address / Address = illegal</li> <li>Address &amp; Address = illegal</li> <li>Address ^ Address = illegal</li> <li>Address | Address = illegal</li> <li> ~Address = illegal</li> </ul> <h2>Pointer to function in C</h2> <p>As we discussed in the previous chapter, a pointer can point to a function in C. However, the declaration of the pointer variable must be the same as the function. Consider the following example to make a pointer pointing to the function. <pre> #include int addition (); int main () { int result; int (*ptr)(); ptr = &amp;addition; result = (*ptr)(); printf(&apos;The sum is %d&apos;,result); } int addition() { int a, b; printf(&apos;Enter two numbers?&apos;); scanf(&apos;%d %d&apos;,&amp;a,&amp;b); return a+b; } </pre> </p><p> <strong>Output</strong> </p> <pre> Enter two numbers?10 15 The sum is 25 </pre> <h2>Pointer to Array of functions in C</h2> <p>To understand the concept of an array of functions, we must understand the array of function. Basically, an array of the function is an array which contains the addresses of functions. In other words, the pointer to an array of functions is a pointer pointing to an array which contains the pointers to the functions. Consider the following example.</p> <pre> #include int show(); int showadd(int); int (*arr[3])(); int (*(*ptr)[3])(); int main () { int result1; arr[0] = show; arr[1] = showadd; ptr = &amp;arr; result1 = (**ptr)(); printf(&apos;printing the value returned by show : %d&apos;,result1); (*(*ptr+1))(result1); } int show() { int a = 65; return a++; } int showadd(int b) { printf(&apos;
Adding 90 to the value returned by show: %d&apos;,b+90); } </pre> <p> <strong>Output</strong> </p> <pre> printing the value returned by show : 65 Adding 90 to the value returned by show: 155 </pre> <hr></5;>

Smanjenje pokazivača u C

Poput inkrementa, možemo dekrementirati pokazivačku varijablu. Ako smanjimo pokazivač, on će početi pokazivati ​​na prethodnu lokaciju. Formula dekrementiranja pokazivača data je u nastavku:

 new_address= current_address - i * size_of(data type) 

32-bitni

Za 32-bitnu int varijablu, smanjit će se za 2 bajta.

64-bitni

Za 64-bitnu int varijablu, smanjit će se za 4 bajta.

Pogledajmo primjer dekrementiranja varijable pokazivača na 64-bitnom OS-u.

 #include void main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p-1; printf('After decrement: Address of p variable is %u 
',p); // P will now point to the immidiate previous location. } 

Izlaz

bash while petlja

 Address of p variable is 3214864300 After decrement: Address of p variable is 3214864296 

C Dodavanje pokazivača

Možemo dodati vrijednost varijabli pokazivača. Formula za dodavanje vrijednosti pokazivaču je navedena u nastavku:

 new_address= current_address + (number * size_of(data type)) 

32-bitni

Za 32-bitnu int varijablu, to će dodati 2 * broj.

64-bitni

Za 64-bitnu int varijablu, to će dodati broj 4 *.

upravljačke strukture python

Pogledajmo primjer dodavanja vrijednosti varijabli pokazivača na 64-bitnoj arhitekturi.

 #include int main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p+3; //adding 3 to pointer variable printf('After adding 3: Address of p variable is %u 
',p); return 0; } 

Izlaz

 Address of p variable is 3214864300 After adding 3: Address of p variable is 3214864312 

Kao što vidite, adresa p je 3214864300. Ali nakon dodavanja 3 s p varijablom, to je 3214864312, tj. 4*3=12 koraka. Budući da koristimo 64-bitnu arhitekturu, povećava se za 12. Ali ako koristimo 32-bitnu arhitekturu, povećava se samo na 6, tj. 2*3=6. Budući da cjelobrojna vrijednost zauzima 2-bajtnu memoriju u 32-bitnom OS-u.

C Oduzimanje pokazivača

Poput zbrajanja pokazivača, možemo oduzeti vrijednost od varijable pokazivača. Oduzimanjem bilo kojeg broja od pokazivača dobit ćete adresu. Formula oduzimanja vrijednosti od pokazivačke varijable je dana u nastavku:

 new_address= current_address - (number * size_of(data type)) 

32-bitni

Za 32-bitnu int varijablu, oduzet će 2 * broj.

64-bitni

Za 64-bitnu int varijablu, oduzet će 4 * broj.

baš elif

Pogledajmo primjer oduzimanja vrijednosti od varijable pokazivača na 64-bitnoj arhitekturi.

 #include int main(){ int number=50; int *p;//pointer to int p=&number;//stores the address of number variable printf('Address of p variable is %u 
',p); p=p-3; //subtracting 3 from pointer variable printf('After subtracting 3: Address of p variable is %u 
',p); return 0; } 

Izlaz

 Address of p variable is 3214864300 After subtracting 3: Address of p variable is 3214864288 

Možete vidjeti nakon oduzimanja 3 od varijable pokazivača, to je 12 (4*3) manje od prethodne vrijednosti adrese.

Međutim, umjesto oduzimanja broja, možemo također oduzeti adresu od druge adrese (pokazivača). To će rezultirati brojem. To neće biti jednostavna aritmetička operacija, ali će slijediti sljedeće pravilo.

Ako su dva pokazivača istog tipa,

 Address2 - Address1 = (Subtraction of two addresses)/size of data type which pointer points 

Razmotrite sljedeći primjer za oduzimanje jednog pokazivača od drugog.

 #include void main () { int i = 100; int *p = &i; int *temp; temp = p; p = p + 3; printf('Pointer Subtraction: %d - %d = %d',p, temp, p-temp); } 

Izlaz

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Nedopuštena aritmetika s pokazivačima

Postoje razne operacije koje se ne mogu izvesti na pokazivačima. Budući da pokazivač pohranjuje adresu, stoga moramo zanemariti operacije koje mogu dovesti do nelegalne adrese, na primjer, zbrajanje i množenje. Popis takvih operacija dan je u nastavku.

• Adresa + Adresa = ilegalno
• Adresa * Adresa = ilegalno
• Adresa % Adresa = ilegalno
• Adresa / Adresa = ilegalno
• Adresa & Adresa = ilegalno
• Adresa ^ Adresa = ilegalno
• Adresa | Adresa = ilegalno
• ~Adresa = ilegalno

Pokazivač na funkciju u C-u

Kao što smo raspravljali u prethodnom poglavlju, pokazivač može pokazivati ​​na funkciju u C-u. Međutim, deklaracija varijable pokazivača mora biti ista kao i funkcija. Razmotrite sljedeći primjer da napravite pokazivač koji pokazuje na funkciju.

 #include int addition (); int main () { int result; int (*ptr)(); ptr = &addition; result = (*ptr)(); printf('The sum is %d',result); } int addition() { int a, b; printf('Enter two numbers?'); scanf('%d %d',&a,&b); return a+b; } 

Izlaz

datoteka otvorena u Javi

 Enter two numbers?10 15 The sum is 25 

Pokazivač na niz funkcija u C-u

Da bismo razumjeli koncept niza funkcija, moramo razumjeti niz funkcija. U osnovi, niz funkcija je niz koji sadrži adrese funkcija. Drugim riječima, pokazivač na niz funkcija je pokazivač koji pokazuje na niz koji sadrži pokazivače na funkcije. Razmotrite sljedeći primjer.

 #include int show(); int showadd(int); int (*arr[3])(); int (*(*ptr)[3])(); int main () { int result1; arr[0] = show; arr[1] = showadd; ptr = &arr; result1 = (**ptr)(); printf('printing the value returned by show : %d',result1); (*(*ptr+1))(result1); } int show() { int a = 65; return a++; } int showadd(int b) { printf('
Adding 90 to the value returned by show: %d',b+90); } 

Izlaz

 printing the value returned by show : 65 Adding 90 to the value returned by show: 155