Wie inkrementiere ich eine Zeigeradresse und einen Zeigerwert?

Lasst uns annehmen,

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

Was macht der folgende Code eigentlich und wie?

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

Ich weiß, das ist in Bezug auf die Codierung etwas chaotisch, aber ich möchte wissen, was tatsächlich passieren wird, wenn wir so codieren.

Hinweis: Nehmen wir an, dass die Adresse von a=5120300in einem Zeiger gespeichert ist, pdessen Adresse lautet 3560200. Was ist nun der Wert p & anach der Ausführung jeder Anweisung?

Erstens hat der Operator ++ Vorrang vor dem Operator *, und die Operatoren () haben Vorrang vor allem anderen.

Zweitens ist der ++ - Zahlenoperator der gleiche wie der Zahl ++ - Operator, wenn Sie sie nichts zuweisen. Der Unterschied besteht darin, dass Zahl ++ die Zahl zurückgibt und dann die Zahl erhöht, und die Zahl ++ zuerst erhöht und dann zurückgibt.

Drittens erhöhen Sie den Wert eines Zeigers, indem Sie ihn um die Größe seines Inhalts erhöhen, dh, Sie erhöhen ihn, als würden Sie in einem Array iterieren.

Um es zusammenzufassen:

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

Da es hier viele Fälle gibt, habe ich möglicherweise einen Fehler gemacht. Bitte korrigieren Sie mich, wenn ich falsch liege.

BEARBEITEN:

Ich habe mich also geirrt, der Vorrang ist etwas komplizierter als das, was ich geschrieben habe. Sehen Sie ihn hier an: http://en.cppreference.com/w/cpp/language/operator_precedence

überprüfte das Programm und die Ergebnisse sind wie folgt:

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

Das Folgende ist eine Instanziierung der verschiedenen Vorschläge zum Ausdrucken. Ich fand es lehrreich.

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

Es kehrt zurück

(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

Ich habe die Zeigeradressen auf geworfen int s gesetzt, damit sie leicht verglichen werden können.

Ich habe es mit GCC zusammengestellt.

In Bezug auf "Wie inkrementiere ich eine Zeigeradresse und einen Zeigerwert?" Ich denke, das ++(*p++);ist eigentlich gut definiert und macht das, wonach Sie fragen, zB:

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

Es wird nicht zweimal vor einem Sequenzpunkt dasselbe geändert. Ich denke nicht, dass es für die meisten Zwecke ein guter Stil ist - es ist ein bisschen zu kryptisch für meinen Geschmack.

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