Zeigeroperationen und Operatorrangfolge in C

Hintergrund

Habe mich heute mit einem C-Typ unterhalten und wir waren uns nicht einig über Folgendes:

int intgA[2] = { 1, 2 };
int intgB[2] = { 3, 5 };

int *intAPtr = intgA;
int *intBPtr = intgB;

Also, wenn wir das tun:

*intAPtr++ = *intBPtr++;

Meine Analyse

Zuerst:

intBPtr Inkremente von eins, jetzt auf die Adresse von 5 zeigend. Dann Ehrerbietung, den Wert 5 halten;

intAPtr ebenfalls inkrementiert um eins und zeigt nun auf die Adresse von 2. Anschließend wird verwiesen und der Wert ist 2;

Zuletzt:

2 wird durch 5 ersetzt.

Das heißt also: 5 und 5.

Seine Analyse

Der Wert von*intBPtr wird zuerst zugeordnet*intAPtr zuerst.

Daher werden sie: 3 und 3.

Dann beide*intAPtr und*intBPtr wird um eins erhöht.

Sie werden also zu: 4 und 4.

Meine Annahme

Ich dachte das++ Operator hat Vorrang vor beiden* und=daher meine Behauptung.

Zum Beispiel, wenn wir hatten:

*intAPtr++; 

Das Ergebnis sollte 2 sein, oder? Weil wir zuerst den Zeiger inkrementieren und dann dereferenzieren.

Warum weisen wir im obigen Fall, wie er behauptet, zuerst den Wert von zu?intBPtr auf den Wert vonintAPtr und erhöhen Sie die Werte zuletzt?

Nachdem ich alle Vorschläge hier aufgenommen habe, habe ich den Code in IDE ausgeführt und das Ergebnis bestätigt den von @sujin:

Obwohl es bestätigt, dass ich zumindest in Bezug auf den Vorrang Recht hatte:

Das:*intAPtr++ = *intBPtr++;

intAPtr++ hat eine höhere Priorität, was zu folgenden Ergebnissen führt:intAPtr erhöht seine Adresse um 1.

Nun zu: der Adresse von 2.

Und ebenso:

intBPtr++ erhöht sich auch um 1 (Adresse).

Nun zu: der Adresse von 5.

Dann ist es*ist dran:

So werden beide dereferenziert (*) zu 2 bzw. 5.

Aber Das Problem besteht immer noch, weil die Zuordnung oben (=) schien nicht stattzufinden.

Wenn es so wäre, würden beide 5 werden.

Ich freue mich darauf, weiter aufgeklärt zu werden.