Putem efectua operații aritmetice pe pointeri, cum ar fi adunarea, scăderea etc. Totuși, deoarece știm că acel pointer conține adresa, rezultatul unei operații aritmetice efectuate pe pointer va fi și un pointer dacă celălalt operand este de tip întreg. În scăderea pointer-din-pointer, rezultatul va fi o valoare întreagă. Următoarele operații aritmetice sunt posibile pe pointer în limbajul C:

• Creştere
• Decrementează
• Plus
• Scădere
• Comparaţie

Creșterea indicatorului în C

Dacă creștem un indicator cu 1, indicatorul va începe să indice către următoarea locație imediată. Aceasta este oarecum diferită de aritmetica generală, deoarece valoarea indicatorului va crește cu dimensiunea tipului de date către care indică indicatorul.

Putem parcurge o matrice utilizând operația de incrementare pe un pointer care va continua să indice fiecare element al matricei, să efectueze o operație asupra acestuia și să se actualizeze într-o buclă.

Regula de creștere a indicatorului este dată mai jos:

 new_address= current_address + i * size_of(data type) 

Unde i este numărul cu care indicatorul crește.

pe 32 de biți

Pentru variabila int pe 32 de biți, aceasta va fi incrementată cu 2 octeți.

pe 64 de biți

Pentru variabila int pe 64 de biți, aceasta va fi incrementată cu 4 octeți.

Să vedem exemplul de incrementare a variabilei pointer pe arhitectura pe 64 de biți.

 #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; } 

Ieșire

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

Parcurgerea unei matrice folosind pointerul

 #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;>

Indicatorul de decrementare în C

La fel ca și increment, putem decrementa o variabilă pointer. Dacă reducem un indicator, acesta va începe să indice locația anterioară. Formula de decrementare a indicatorului este dată mai jos:

 new_address= current_address - i * size_of(data type) 

pe 32 de biți

Pentru variabila int pe 32 de biți, aceasta va fi decrementată cu 2 octeți.

pe 64 de biți

Pentru variabila int pe 64 de biți, aceasta va fi decrementată cu 4 octeți.

Să vedem exemplul de decrementare a variabilei pointer pe sistemul de operare pe 64 de biți.

 #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. } 

Ieșire

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

Adăugarea indicatorului C

Putem adăuga o valoare variabilei pointer. Formula de adăugare a valorii indicatorului este dată mai jos:

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

pe 32 de biți

Pentru variabila int pe 32 de biți, va adăuga 2 * număr.

pe 64 de biți

Pentru variabila int pe 64 de biți, va adăuga un număr de 4 *.

Să vedem exemplul de adăugare a valorii variabilei pointer pe arhitectura pe 64 de biți.

 #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; } 

Ieșire

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

După cum puteți vedea, adresa lui p este 3214864300. Dar după adăugarea 3 cu variabila p, este 3214864312, adică 4*3=12 increment. Deoarece folosim arhitectura pe 64 de biți, aceasta crește cu 12. Dar dacă am folosit arhitectura pe 32 de biți, aceasta crește doar la 6, adică 2*3=6. Deoarece valoarea întreagă ocupă o memorie de 2 octeți în sistemul de operare pe 32 de biți.

Scăderea indicatorului C

Ca și adăugarea pointerului, putem scădea o valoare din variabila pointer. Scăderea oricărui număr dintr-un indicator va da o adresă. Formula de scădere a valorii din variabila pointer este dată mai jos:

adăugați șir de caractere java

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

pe 32 de biți

Pentru variabila int pe 32 de biți, va scădea 2 * număr.

pe 64 de biți

Pentru variabila int pe 64 de biți, va scădea 4 * număr.

Să vedem exemplul de scădere a valorii din variabila pointer pe arhitectura pe 64 de biți.

 #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; } 

Ieșire

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

Puteți vedea după scăderea 3 din variabila pointer, este cu 12 (4*3) mai puțin decât valoarea adresei anterioare.

Totuși, în loc să scădem un număr, putem scădea și o adresă dintr-o altă adresă (pointer). Acest lucru va avea ca rezultat un număr. Nu va fi o operație aritmetică simplă, dar va urma următoarea regulă.

Dacă două indicatori sunt de același tip,

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

Luați în considerare următorul exemplu pentru a scădea un indicator dintr-un altul.

 #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); } 

Ieșire

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Aritmetică ilegală cu indicatori

Există diverse operații care nu pot fi efectuate pe pointere. Deoarece pointerul stochează adresa, trebuie să ignorăm operațiunile care pot duce la o adresă ilegală, de exemplu, adunarea și înmulțirea. O listă cu astfel de operațiuni este prezentată mai jos.

• Adresă + Adresă = ilegal
• Adresa * Adresa = ilegal
• Adresă % Adresă = ilegal
• Adresa / Adresa = ilegal
• Adresă și adresă = ilegale
• Adresă ^ Adresă = ilegal
• Adresa | Adresa = ilegal
• ~Adresa = ilegal

Pointer la funcția în C

După cum am discutat în capitolul anterior, un pointer poate indica o funcție în C. Totuși, declarația variabilei pointer trebuie să fie aceeași cu funcția. Luați în considerare următorul exemplu pentru a face un pointer care să indice funcția.

 #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; } 

Ieșire

 Enter two numbers?10 15 The sum is 25 

Pointer la Matrice de funcții în C

Pentru a înțelege conceptul de matrice de funcții, trebuie să înțelegem matrice de funcție. Practic, o matrice a funcției este o matrice care conține adresele funcțiilor. Cu alte cuvinte, pointerul către o matrice de funcții este un pointer care indică către o matrice care conține pointerii către funcții. Luați în considerare următorul exemplu.

 #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); } 

Ieșire

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