Podemos realizar operaciones aritméticas en los punteros como suma, resta, etc. Sin embargo, como sabemos que el puntero contiene la dirección, el resultado de una operación aritmética realizada en el puntero también será un puntero si el otro operando es de tipo entero. En la resta de puntero a puntero, el resultado será un valor entero. Son posibles las siguientes operaciones aritméticas con el puntero en lenguaje C:

fusionar ordenamiento java

• Incremento
• Decremento
• Suma
• Sustracción
• Comparación

Puntero incremental en C

Si incrementamos un puntero en 1, el puntero comenzará a apuntar a la siguiente ubicación inmediata. Esto es algo diferente de la aritmética general ya que el valor del puntero aumentará según el tamaño del tipo de datos al que apunta el puntero.

Podemos recorrer una matriz usando la operación de incremento en un puntero que seguirá apuntando a cada elemento de la matriz, realizará alguna operación sobre eso y se actualizará en un bucle.

La regla para incrementar el puntero se proporciona a continuación:

 new_address= current_address + i * size_of(data type) 

Donde i es el número en el que se incrementa el puntero.

32 bits

Para la variable int de 32 bits, se incrementará en 2 bytes.

64 bits

Para la variable int de 64 bits, se incrementará en 4 bytes.

Veamos el ejemplo de variable de puntero incremental en una arquitectura de 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; } 

Producción

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

Atravesando una matriz usando un puntero

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

Puntero decreciente en C

Al igual que el incremento, podemos disminuir una variable de puntero. Si disminuimos un puntero, comenzará a apuntar a la ubicación anterior. La fórmula para disminuir el puntero se proporciona a continuación:

 new_address= current_address - i * size_of(data type) 

32 bits

Para la variable int de 32 bits, se reducirá en 2 bytes.

64 bits

Para la variable int de 64 bits, se reducirá en 4 bytes.

Veamos el ejemplo de variable de puntero decremental en un sistema operativo 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. } 

Producción

matriz en java

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

Adición de puntero C

Podemos agregar un valor a la variable de puntero. La fórmula para agregar valor al puntero se proporciona a continuación:

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

32 bits

Para la variable int de 32 bits, agregará 2 * número.

64 bits

Para la variable int de 64 bits, agregará un número 4 *.

algoritmo de ordenación del montón

Veamos el ejemplo de cómo agregar valor a una variable de puntero en una arquitectura de 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; } 

Producción

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

Como puede ver, la dirección de p es 3214864300. Pero después de sumar 3 con la variable p, es 3214864312, es decir, incremento de 4*3=12. Como usamos una arquitectura de 64 bits, se incrementa en 12. Pero si usamos una arquitectura de 32 bits, se incrementa solo a 6, es decir, 2*3=6. Como valor entero ocupa 2 bytes de memoria en un sistema operativo de 32 bits.

Resta del puntero C

Al igual que la suma de punteros, podemos restar un valor de la variable de puntero. Restar cualquier número de un puntero dará una dirección. La fórmula para restar el valor de la variable puntero se proporciona a continuación:

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

32 bits

Para la variable int de 32 bits, restará 2 * número.

64 bits

Para la variable int de 64 bits, restará 4 * número.

analizar cadena a int

Veamos el ejemplo de restar valor de la variable de puntero en una arquitectura de 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; } 

Producción

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

Puede ver que después de restar 3 de la variable del puntero, es 12 (4*3) menos que el valor de la dirección anterior.

Sin embargo, en lugar de restar un número, también podemos restar una dirección de otra dirección (puntero). Esto dará como resultado un número. No será una operación aritmética sencilla, sino que seguirá la siguiente regla.

Si dos punteros son del mismo tipo,

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

Considere el siguiente ejemplo para restar un puntero de otro.

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

Producción

 Pointer Subtraction: 1030585080 - 1030585068 = 3 

Aritmética ilegal con punteros

Hay varias operaciones que no se pueden realizar con punteros. Dado que el puntero almacena la dirección, debemos ignorar las operaciones que pueden conducir a una dirección ilegal, por ejemplo, la suma y la multiplicación. A continuación se proporciona una lista de dichas operaciones.

• Dirección + Dirección = ilegal
• Dirección * Dirección = ilegal
• Dirección % Dirección = ilegal
• Dirección / Dirección = ilegal
• Dirección y dirección = ilegal
• Dirección ^ Dirección = ilegal
• Dirección | Dirección = ilegal
• ~Dirección = ilegal

Puntero para funcionar en C

Como comentamos en el capítulo anterior, un puntero puede apuntar a una función en C. Sin embargo, la declaración de la variable del puntero debe ser la misma que la de la función. Considere el siguiente ejemplo para hacer un puntero que apunte a la función.

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

Producción

¿Qué es gb?

 Enter two numbers?10 15 The sum is 25 

Puntero a matriz de funciones en C

Para comprender el concepto de matriz de funciones, debemos comprender la matriz de funciones. Básicamente, una matriz de una función es una matriz que contiene las direcciones de las funciones. En otras palabras, el puntero a una matriz de funciones es un puntero que apunta a una matriz que contiene los punteros a las funciones. Considere el siguiente ejemplo.

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

Producción

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