Come incrementare l'indirizzo di un puntatore e il valore del puntatore?

Supponiamo,

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

Cosa farà effettivamente il codice seguente e come?

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

Lo so, questo è un po 'complicato in termini di codifica, ma voglio sapere cosa accadrà effettivamente quando codificheremo in questo modo.

Nota: supponiamo che l'indirizzo di a=5120300, sia memorizzato nel puntatore il pcui indirizzo è 3560200. Ora, quale sarà il valore p & adopo l'esecuzione di ogni istruzione?

Per prima cosa, l'operatore ++ ha la precedenza sull'operatore * e gli operatori () hanno la precedenza su tutto il resto.

Secondo, l'operatore numero ++ è lo stesso dell'operatore numero ++ se non li assegni a nulla. La differenza è numero ++ restituisce numero e quindi incrementa numero e ++ numero incrementa prima e poi lo restituisce.

Terzo, aumentando il valore di un puntatore, lo stai incrementando della dimensione del suo contenuto, ovvero lo stai incrementando come se stessi iterando in un array.

Quindi, per riassumere tutto:

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

Poiché ci sono molti casi qui, potrei aver fatto qualche errore, per favore correggimi se sbaglio.

MODIFICARE:

Quindi mi sbagliavo, la precedenza è un po 'più complicata di quello che ho scritto, guardala qui: http://en.cppreference.com/w/cpp/language/operator_precedence

controllato il programma e i risultati sono come,

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

Quello che segue è un'istanza dei vari suggerimenti "stampalo". L'ho trovato istruttivo.

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

Ritorna

(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

Ho lanciato gli indirizzi del puntatore su ints in modo che possano essere facilmente confrontati.

L'ho compilato con GCC.

Riguardo a "Come incrementare un indirizzo del puntatore e il valore del puntatore?" Penso che in ++(*p++);realtà sia ben definito e fa quello che stai chiedendo, ad esempio:

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

Non sta modificando la stessa cosa due volte prima di un punto della sequenza. Non penso che sia un buon stile per la maggior parte degli usi: è un po 'troppo criptico per i miei gusti.

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