Possiamo eseguire operazioni aritmetiche sui puntatori come addizione, sottrazione, ecc. Tuttavia, poiché sappiamo che il puntatore contiene l'indirizzo, anche il risultato di un'operazione aritmetica eseguita sul puntatore sarà un puntatore se l'altro operando è di tipo intero. Nella sottrazione puntatore da puntatore, il risultato sarà un valore intero. Sul puntatore in linguaggio C sono possibili le seguenti operazioni aritmetiche:

• Incremento
• Decremento
• Aggiunta
• Sottrazione
• Confronto

Puntatore incrementale in C

Se incrementiamo un puntatore di 1, il puntatore inizierà a puntare alla posizione immediatamente successiva. Questo è leggermente diverso dall'aritmetica generale poiché il valore del puntatore verrà aumentato della dimensione del tipo di dati a cui punta il puntatore.

Possiamo attraversare un array utilizzando l'operazione di incremento su un puntatore che continuerà a puntare a ogni elemento dell'array, eseguirà alcune operazioni su quello e si aggiornerà in un ciclo.

La regola per incrementare il puntatore è riportata di seguito:

 new_address= current_address + i * size_of(data type) 

Dove i è il numero di cui viene incrementato il puntatore.

32 bit

Per la variabile int a 32 bit, verrà incrementata di 2 byte.

aggiungi la stringa java

64 bit

Per la variabile int a 64 bit, verrà incrementata di 4 byte.

Vediamo l'esempio di incremento della variabile puntatore su architettura a 64 bit.

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

Produzione

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

Attraversamento di un array utilizzando il puntatore

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

Puntatore decrementale in C

Come l'incremento, possiamo decrementare una variabile puntatore. Se decrementiamo un puntatore, inizierà a puntare alla posizione precedente. La formula per decrementare il puntatore è riportata di seguito:

 new_address= current_address - i * size_of(data type) 

32 bit

Per la variabile int a 32 bit, verrà decrementata di 2 byte.

64 bit

Per la variabile int a 64 bit, verrà decrementata di 4 byte.

Vediamo l'esempio di decremento della variabile puntatore sul sistema operativo a 64 bit.

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

Produzione

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

Aggiunta di puntatori C

Possiamo aggiungere un valore alla variabile puntatore. La formula per aggiungere valore al puntatore è riportata di seguito:

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

32 bit

Per la variabile int a 32 bit, aggiungerà 2 * numero.

64 bit

Per la variabile int a 64 bit, aggiungerà 4 * numero.

Vediamo l'esempio di aggiunta di valore alla variabile puntatore su un'architettura a 64 bit.

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

Produzione

cambiare programmazione Java

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

Come puoi vedere, l'indirizzo di p è 3214864300. Ma dopo aver aggiunto 3 con la variabile p, è 3214864312, ovvero 4*3=incremento di 12. Poiché utilizziamo un'architettura a 64 bit, aumenta 12. Ma se utilizzassimo un'architettura a 32 bit, aumenterà solo fino a 6, ovvero 2*3=6. Poiché il valore intero occupa 2 byte di memoria nel sistema operativo a 32 bit.

Sottrazione del puntatore C

Come l'addizione di puntatori, possiamo sottrarre un valore dalla variabile puntatore. Sottraendo qualsiasi numero da un puntatore si otterrà un indirizzo. La formula per sottrarre il valore dalla variabile puntatore è riportata di seguito:

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

32 bit

Per la variabile int a 32 bit, sottrarrà 2 * numero.

64 bit

Per la variabile int a 64 bit, sottrarrà 4 * numero.

Vediamo l'esempio di sottrazione di valore dalla variabile puntatore su un'architettura a 64 bit.

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

Produzione

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

Puoi vedere che dopo aver sottratto 3 dalla variabile puntatore, è 12 (4*3) in meno rispetto al valore dell'indirizzo precedente.

Tuttavia, invece di sottrarre un numero, possiamo anche sottrarre un indirizzo da un altro indirizzo (puntatore). Ciò risulterà in un numero. Non sarà una semplice operazione aritmetica, ma seguirà la seguente regola.

Se due puntatori sono dello stesso tipo,

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

Considera l'esempio seguente per sottrarre un puntatore da un altro.

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

Produzione

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Aritmetica illegale con i puntatori

Esistono varie operazioni che non possono essere eseguite sui puntatori. Poiché il puntatore memorizza l'indirizzo, dobbiamo ignorare le operazioni che potrebbero portare a un indirizzo illegale, ad esempio addizione e moltiplicazione. Di seguito è riportato un elenco di tali operazioni.

• Indirizzo + Indirizzo = illegale
• Indirizzo * Indirizzo = illegale
• Indirizzo % Indirizzo = illegale
• Indirizzo / Indirizzo = illegale
• Indirizzo e indirizzo = illegale
• Indirizzo ^ Indirizzo = illegale
• Indirizzo | Indirizzo = illegale
• ~Indirizzo = illegale

Puntatore alla funzione in C

Come abbiamo discusso nel capitolo precedente, un puntatore può puntare a una funzione in C. Tuttavia, la dichiarazione della variabile puntatore deve essere la stessa della funzione. Considera l'esempio seguente per creare un puntatore che punti alla funzione.

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

Produzione

 Enter two numbers?10 15 The sum is 25 

Puntatore ad array di funzioni in C

Per comprendere il concetto di array di funzioni, dobbiamo comprendere l'array di funzioni. Fondamentalmente, un array della funzione è un array che contiene gli indirizzi delle funzioni. In altre parole, il puntatore a un array di funzioni è un puntatore che punta a un array che contiene i puntatori alle funzioni. Considera il seguente esempio.

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

Produzione

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