Nous pouvons effectuer des opérations arithmétiques sur les pointeurs comme l'addition, la soustraction, etc. Cependant, comme nous savons que le pointeur contient l'adresse, le résultat d'une opération arithmétique effectuée sur le pointeur sera également un pointeur si l'autre opérande est de type entier. Dans la soustraction pointeur à partir d’un pointeur, le résultat sera une valeur entière. Les opérations arithmétiques suivantes sont possibles sur le pointeur en langage C :

• Incrément
• Décrémenter
• Ajout
• Soustraction
• Comparaison

Incrémentation du pointeur en C

Si nous incrémentons un pointeur de 1, le pointeur commencera à pointer vers l'emplacement suivant immédiat. Ceci est quelque peu différent de l'arithmétique générale puisque la valeur du pointeur sera augmentée par la taille du type de données vers lequel pointe le pointeur.

Nous pouvons parcourir un tableau en utilisant l'opération d'incrémentation sur un pointeur qui continuera à pointer vers chaque élément du tableau, effectuera une opération sur celui-ci et se mettra à jour dans une boucle.

La règle pour incrémenter le pointeur est donnée ci-dessous :

 new_address= current_address + i * size_of(data type) 

Où i est le nombre par lequel le pointeur est augmenté.

32 bits

Pour une variable int 32 bits, elle sera incrémentée de 2 octets.

contient dans la chaîne

64 bits

Pour une variable int 64 bits, elle sera incrémentée de 4 octets.

Voyons l'exemple d'incrémentation d'une variable de pointeur sur une architecture 64 bits.

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

Sortir

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

Parcourir un tableau à l'aide d'un pointeur

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

Décrémentation du pointeur en C

Comme pour l'incrémentation, nous pouvons décrémenter une variable de pointeur. Si nous décrémentons un pointeur, il commencera à pointer vers l'emplacement précédent. La formule de décrémentation du pointeur est donnée ci-dessous :

 new_address= current_address - i * size_of(data type) 

32 bits

Pour une variable int 32 bits, elle sera décrémentée de 2 octets.

64 bits

Pour une variable int 64 bits, elle sera décrémentée de 4 octets.

Voyons l'exemple de décrémentation d'une variable de pointeur sur un système d'exploitation 64 bits.

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

Sortir

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

Ajout de pointeur C

Nous pouvons ajouter une valeur à la variable pointeur. La formule d’ajout de valeur au pointeur est donnée ci-dessous :

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

32 bits

Pour une variable int 32 bits, cela ajoutera un nombre 2 *.

64 bits

Pour une variable int 64 bits, cela ajoutera un nombre 4 *.

Voyons l'exemple d'ajout de valeur à une variable de pointeur sur une architecture 64 bits.

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

Sortir

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

Comme vous pouvez le voir, l'adresse de p est 3214864300. Mais après avoir ajouté 3 avec la variable p, c'est 3214864312, c'est-à-dire 4*3=12 incréments. Puisque nous utilisons une architecture 64 bits, cela incrémente de 12. Mais si nous utilisions une architecture 32 bits, cela incrémentait à 6 seulement, c'est-à-dire 2*3=6. Comme la valeur entière occupe 2 octets de mémoire dans un système d'exploitation 32 bits.

Soustraction du pointeur C

Comme pour l’ajout d’un pointeur, nous pouvons soustraire une valeur à la variable pointeur. Soustraire n’importe quel nombre d’un pointeur donnera une adresse. La formule de soustraction de la valeur de la variable pointeur est donnée ci-dessous :

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

32 bits

Pour une variable int 32 bits, cela soustraira 2 * nombre.

64 bits

Pour une variable int 64 bits, cela soustraira 4 * nombre.

Voyons l'exemple de soustraction de valeur de la variable pointeur sur une architecture 64 bits.

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

Sortir

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

Vous pouvez voir qu'après avoir soustrait 3 de la variable de pointeur, c'est 12 (4*3) de moins que la valeur d'adresse précédente.

Cependant, au lieu de soustraire un nombre, on peut également soustraire une adresse à une autre adresse (pointeur). Cela se traduira par un numéro. Ce ne sera pas une simple opération arithmétique, mais elle suivra la règle suivante.

Si deux pointeurs sont du même type,

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

Considérez l'exemple suivant pour soustraire un pointeur d'un autre.

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

Sortir

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Arithmétique illégale avec des pointeurs

Il existe diverses opérations qui ne peuvent pas être effectuées sur les pointeurs. Étant donné que le pointeur stocke l'adresse, nous devons donc ignorer les opérations qui peuvent conduire à une adresse illégale, par exemple l'addition et la multiplication. Une liste de ces opérations est donnée ci-dessous.

• Adresse + Adresse = illégal
• Adresse * Adresse = illégal
• Adresse % Adresse = illégal
• Adresse / Adresse = illégal
• Adresse & Adresse = illégal
• Adresse ^ Adresse = illégal
• Adresse | Adresse = illégal
• ~Adresse = illégal

Pointeur pour fonctionner en C

Comme nous l'avons vu dans le chapitre précédent, un pointeur peut pointer vers une fonction en C. Cependant, la déclaration de la variable pointeur doit être la même que celle de la fonction. Considérez l'exemple suivant pour créer un pointeur pointant vers la fonction.

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

Sortir

 Enter two numbers?10 15 The sum is 25 

Pointeur vers un tableau de fonctions en C

Pour comprendre le concept de tableau de fonctions, nous devons comprendre le tableau de fonctions. Fondamentalement, un tableau de fonction est un tableau qui contient les adresses des fonctions. En d’autres termes, le pointeur vers un tableau de fonctions est un pointeur pointant vers un tableau qui contient les pointeurs vers les fonctions. Considérez l'exemple suivant.

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

Sortir

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