¿Cómo incrementar una dirección de puntero y el valor de un puntero?

Asummos,

int *p; int a = 100; p = &a; 

¿Qué hará el siguiente código en realidad y cómo?

 p++; ++p; ++*p; ++(*p); ++*(p); *p++; (*p)++; *(p)++; *++p; *(++p); 

Lo sé, es un poco complicado en términos de encoding, pero quiero saber qué sucederá realmente cuando codifiquemos de esta manera.

Nota: supongamos que la dirección de a=5120300 , se almacena en el puntero p cuya dirección es 3560200 . Ahora, ¿cuál será el valor de p & a después de la ejecución de cada statement?

En primer lugar, el operador ++ tiene prioridad sobre el operador * y los operadores () tienen prioridad sobre todo lo demás.

En segundo lugar, el operador de número ++ es el mismo que el operador de ++ si no los está asignando a nada. La diferencia es number ++ returns number y luego incrementa el número, y ++ number se incrementa primero y luego lo devuelve.

Tercero, al boost el valor de un puntero, lo estás incrementando por el tamaño de su contenido, es decir, lo estás incrementando como si estuvieras iterando en una matriz.

Entonces, para resumir todo:

 ptr++; // Pointer moves to the next int position (as if it was an array) ++ptr; // Pointer moves to the next int position (as if it was an array) ++*ptr; // The value of ptr is incremented ++(*ptr); // The value of ptr is incremented ++*(ptr); // The value of ptr is incremented *ptr++; // Pointer moves to the next int position (as if it was an array). But returns the old content (*ptr)++; // The value of ptr is incremented *(ptr)++; // Pointer moves to the next int position (as if it was an array). But returns the old content *++ptr; // Pointer moves to the next int position, and then get's accessed, with your code, segfault *(++ptr); // Pointer moves to the next int position, and then get's accessed, with your code, segfault 

Como hay muchos casos aquí, podría haber cometido un error, por favor corrígeme si me equivoco.

EDITAR:

Así que estaba equivocado, la precedencia es un poco más complicada de lo que escribí, mire aquí: http://en.cppreference.com/w/cpp/language/operator_precedence

comprobado el progtwig y los resultados son como,

 p++; // use it then move to next int position ++p; // move to next int and then use it ++*p; // increments the value by 1 then use it ++(*p); // increments the value by 1 then use it ++*(p); // increments the value by 1 then use it *p++; // use the value of p then moves to next position (*p)++; // use the value of p then increment the value *(p)++; // use the value of p then moves to next position *++p; // moves to the next int location then use that value *(++p); // moves to next location then use that value 

Con respecto a “Cómo incrementar una dirección de puntero y el valor del puntero?” Creo que ++(*p++); está realmente bien definido y hace lo que está pidiendo, por ejemplo:

 #include  int main() { int a = 100; int *p = &a; printf("%p\n",(void*)p); ++(*p++); printf("%p\n",(void*)p); printf("%d\n",a); return 0; } 

No está modificando lo mismo dos veces antes de un punto de secuencia. Aunque no creo que sea un buen estilo para la mayoría de los usos, es demasiado críptico para mi gusto.

La siguiente es una instancia de varias sugerencias de “solo imprimirlo”. Lo encontré instructivo.

 #include "stdio.h" int main() { static int x = 5; static int *p = &x; printf("(int) p => %d\n",(int) p); printf("(int) p++ => %d\n",(int) p++); x = 5; p = &x; printf("(int) ++p => %d\n",(int) ++p); x = 5; p = &x; printf("++*p => %d\n",++*p); x = 5; p = &x; printf("++(*p) => %d\n",++(*p)); x = 5; p = &x; printf("++*(p) => %d\n",++*(p)); x = 5; p = &x; printf("*p++ => %d\n",*p++); x = 5; p = &x; printf("(*p)++ => %d\n",(*p)++); x = 5; p = &x; printf("*(p)++ => %d\n",*(p)++); x = 5; p = &x; printf("*++p => %d\n",*++p); x = 5; p = &x; printf("*(++p) => %d\n",*(++p)); return 0; } 

Vuelve

 (int) p => 256688152 (int) p++ => 256688152 (int) ++p => 256688156 ++*p => 6 ++(*p) => 6 ++*(p) => 6 *p++ => 5 (*p)++ => 5 *(p)++ => 5 *++p => 0 *(++p) => 0 

Eché las direcciones del puntero a int s para que se puedan comparar fácilmente.

Lo compilé con GCC.

  Note: 1) Both ++ and * have same precedence(priority), so the associativity comes into picture. 2) in this case Associativity is from **Right-Left** important table to remember in case of pointers and arrays: operators precedence associativity 1) () , [] 1 left-right 2) * , identifier 2 right-left 3)  3 ---------- let me give an example, this might help; char **str; str = (char **)malloc(sizeof(char*)*2); // allocate mem for 2 char* str[0]=(char *)malloc(sizeof(char)*10); // allocate mem for 10 char str[1]=(char *)malloc(sizeof(char)*10); // allocate mem for 10 char strcpy(str[0],"abcd"); // assigning value strcpy(str[1],"efgh"); // assigning value while(*str) { cout<<*str<