Y no se incrementa

Este es el progtwig:

#include void main() { int *x,*y; int a=23,b=56; x=&a; y=&b; printf("%d\t%d",x,y); x++; y++; /* here only x is incremented but y remains same. What is the reason? */ printf("\n%d\t%d",x,y); } 

es decir, x se incrementa en 2. Pero y se mantiene como está. ¿Cómo?

No hay garantía de que sus punteros tengan el mismo tamaño que sus enteros, por lo que realmente no debería usar %d como especificador de formato.

He visto problemas similares a esto cuando las personas pasan variables long a printf con un especificador para un int . Debido a que el largo era más ancho que el int , confundía a printf respecto a dónde estaban las cosas en la stack.

Deberías estar usando %p para los punteros. También hay muchos otros problemas con ese código, según los estándares. Intente lo siguiente como punto de partida:

 #include  int main (void) { int *x, *y; int a = 23, b = 56; x=&a; y=&b; printf ("%p %p\n", x, y); x++; y++; printf ("%p %p\n", x, y); return 0; } 

Aquí hay una explicación posible (gracias al comentario de Michael Burr):

Digamos que su puntero es de 32 bits y sus enteros son de 16 bits y que está en una architecture little-endian (como Intel).

Además, suponga que la dirección de a es 0x12345678 y la dirección de b es 0x1234567a .

Cuando los pasas a printf , presionas dos valores de 32 bits en la stack, pero printf solo lee dos valores de 16 bits, ya que se ha dicho que con los especificadores de formato %d %d :

  himem -------- / | 0x12 | push | 0x34 | | | 0x56 | \ | 0x78 | -------- / | 0x12 | \ printf reads 0x1234 push | 0x34 | / | | 0x56 | \ printf reads 0x567a \ | 0x7a | / -------- lomem 

Luego, cuando incrementas ambos punteros y llamas a printf nuevamente, obtienes:

  himem -------- / | 0x12 | push | 0x34 | | | 0x56 | \ | 0x7a | -------- / | 0x12 | \ printf reads 0x1234 push | 0x34 | / | | 0x56 | \ printf reads 0x567c \ | 0x7c | / -------- lomem 

Entonces, en ese escenario, puede ver por qué parece que solo se ha incrementado un puntero, pero el problema real es que no está imprimiendo los punteros, sino que está imprimiendo la mitad más significativa de uno de ellos (que probablemente ganó No cambie) y la mitad menos significativa de la misma (que cambiará).

¿qué tal … int * x; int * y; en lugar de int * x, * y;

Hola incrementas tu dirección de puntero, no uso de valor (*x)++ (*y)++

En su código, está accediendo a un puntero e incrementando un puntero. Lo que podrías querer hacer es esto:

 void main() { int *x,*y; int a=23,b=56; x=&a; y=&b; printf("%d\t%d",*x,*y); (*x)++; (*y)++; printf("\n%d\t%d",*x,*y); return 0; } 

Observe que (* x) ++ y (* y) ++ para acceder al valor del puntero, ya que es esto, usted desea incrementar. Si escribe x ++ o y ++, incrementará el puntero, lo que significa que empujará la dirección hacia donde apunta hacia adelante. Esto lleva en su caso a valores indefinidos.

estás incrementando los punteros , no los valores si eso es alguna ayuda.

No puedo decirte más, ya que esa fuente no se comstack realmente y te da aproximadamente la misma advertencia que hice 🙂

 #include int main(int argc, char *argv[]) { int *x,*y; int a=23,b=56; x=&a; y=&b; printf("%d\t\t%d",*x,*y); x++; y++; printf("\n%d\t\t%d",*x,*y); return 0; } 

que se comstackrá y muestra el contenido en mi comstackdor que da como resultado el siguiente resultado:

 23 56 1606415920 23 

(Pongo los dos ‘\ t’ por línea para garantizar la separación de valores, esto no afecta al rest del código)

ya que asumo que desea que el código aumente b el código sería el siguiente:

 #include int main(int argc, char *argv[]) { int *x,*y; int a=23,b=56; x=&a; y=&b; printf("%d\t\t%d",*x,*y); (*x)++; (*y)++; printf("\n%d\t\t%d",*x,*y); return 0; } 

que imprime:

 23 56 24 57 

Por favor el progtwig:

 #include void main() { int *x= NULL; int *y = NULL; int a=23,b=56; x=&a; y=&b; printf("%x\t%x",x,y); x++; y++; printf("\n%x\t%x",x,y); } 

Creo que debería estar bien entonces. Solo los valores se inicializan correctamente.