Podemos realizar operações aritméticas nos ponteiros como adição, subtração, etc. Porém, como sabemos que o ponteiro contém o endereço, o resultado de uma operação aritmética realizada no ponteiro também será um ponteiro se o outro operando for do tipo inteiro. Na subtração ponteiro a ponteiro, o resultado será um valor inteiro. As seguintes operações aritméticas são possíveis no ponteiro na linguagem C:

• Incremento
• Diminuir
• Adição
• Subtração
• Comparação

Incrementando o ponteiro em C

Se incrementarmos um ponteiro em 1, o ponteiro começará a apontar para o próximo local imediato. Isso é um pouco diferente da aritmética geral, pois o valor do ponteiro aumentará de acordo com o tamanho do tipo de dados para o qual o ponteiro está apontando.

Podemos percorrer um array usando a operação de incremento em um ponteiro que continuará apontando para cada elemento do array, realizar alguma operação nele e se atualizar em um loop.

A regra para incrementar o ponteiro é fornecida abaixo:

 new_address= current_address + i * size_of(data type) 

Onde i é o número pelo qual o ponteiro aumenta.

32 bits

Para variável int de 32 bits, ela será incrementada em 2 bytes.

é igual ao método java

64 bits

Para variável int de 64 bits, ela será incrementada em 4 bytes.

Vamos ver o exemplo de incremento de variável de ponteiro na arquitetura de 64 bits.

meulivecricket.

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

Saída

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

Percorrendo um array usando ponteiro

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

Ponteiro decrescente em C

Assim como o incremento, podemos decrementar uma variável de ponteiro. Se diminuirmos um ponteiro, ele começará a apontar para o local anterior. A fórmula para decrementar o ponteiro é fornecida abaixo:

 new_address= current_address - i * size_of(data type) 

32 bits

Para variável int de 32 bits, ela será decrementada em 2 bytes.

64 bits

Para variável int de 64 bits, ela será decrementada em 4 bytes.

Vamos ver o exemplo de diminuição da variável de ponteiro no sistema operacional de 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. } 

Saída

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

Adição de ponteiro C

Podemos adicionar um valor à variável ponteiro. A fórmula para adicionar valor ao ponteiro é fornecida abaixo:

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

32 bits

Para variável int de 32 bits, ele adicionará 2 * número.

64 bits

Para variável int de 64 bits, ele adicionará 4 * número.

Vejamos o exemplo de adição de valor à variável de ponteiro na arquitetura de 64 bits.

lançar SQL

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

Saída

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

Como você pode ver, o endereço de p é 3214864300. Mas depois de adicionar 3 com a variável p, é 3214864312, ou seja, 4*3=12 incrementos. Como estamos usando uma arquitetura de 64 bits, ela incrementa 12. Mas se estivéssemos usando uma arquitetura de 32 bits, ela incrementava apenas 6, ou seja, 2*3=6. Como o valor inteiro ocupa 2 bytes de memória no sistema operacional de 32 bits.

Subtração de ponteiro C

Assim como a adição de ponteiro, podemos subtrair um valor da variável de ponteiro. Subtrair qualquer número de um ponteiro resultará em um endereço. A fórmula para subtrair o valor da variável ponteiro é fornecida abaixo:

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

32 bits

Para variável int de 32 bits, subtrairá 2 * número.

64 bits

Para variável int de 64 bits, subtrairá 4 * número.

Vejamos o exemplo de subtração de valor da variável ponteiro na arquitetura de 64 bits.

tamanho do texto em látex

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

Saída

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

Você pode ver que depois de subtrair 3 da variável do ponteiro, é 12 (4*3) menor que o valor do endereço anterior.

Porém, em vez de subtrair um número, também podemos subtrair um endereço de outro endereço (ponteiro). Isso resultará em um número. Não será uma simples operação aritmética, mas seguirá a seguinte regra.

Se dois ponteiros forem do mesmo tipo,

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

Considere o exemplo a seguir para subtrair um ponteiro de outro.

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

Saída

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Aritmética ilegal com ponteiros

Existem várias operações que não podem ser executadas em ponteiros. Como o ponteiro armazena endereços, devemos ignorar as operações que podem levar a um endereço ilegal, por exemplo, adição e multiplicação. Uma lista de tais operações é fornecida abaixo.

• Endereço + Endereço = ilegal
• Endereço * Endereço = ilegal
• Endereço % Endereço = ilegal
• Endereço / Endereço = ilegal
• Endereço e endereço = ilegal
• Endereço ^ Endereço = ilegal
• Endereço | Endereço = ilegal
• ~Endereço = ilegal

Ponteiro para função em C

Conforme discutimos no capítulo anterior, um ponteiro pode apontar para uma função em C. No entanto, a declaração da variável do ponteiro deve ser igual à da função. Considere o exemplo a seguir para fazer um ponteiro apontando para a função.

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

Saída

data java para string

 Enter two numbers?10 15 The sum is 25 

Ponteiro para array de funções em C

Para entender o conceito de array de funções, devemos entender o array de funções. Basicamente, um array da função é um array que contém os endereços das funções. Em outras palavras, o ponteiro para um array de funções é um ponteiro que aponta para um array que contém os ponteiros para as funções. Considere o seguinte exemplo.

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

Saída

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