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

punteros como parametros de funciones en c

Question

Asumamos,

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 codificación, 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 declaración?

Answer 1

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 <stdio.h>

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.

Answer 2

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 aumentar 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

Answer 3

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.

Answer 4

comprobado el programa 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

Answer 5

        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)  <data type>            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<<endl;   // printing the string
            *str++;             // incrementing the address(pointer)
                                // check above about the prcedence and associativity
        }
        free(str[0]);
        free(str[1]);
        free(str);