Unterschied zwischen * y ++ und ++ * y?

Question

Ich bin verwirrt, wie dieser Code ausgeführt wird. Angenommen, wir haben

int x=30,*y,*z; 
y=&x; 

Was ist der Unterschied zwischen * y ++ und ++ * y? Und was wird das Ergebnis dieses Programms sein?

#include<stdio.h> 
int main(){ 

    int x=30,*y,*z; 
    y=&x; 
    z=y; 
    *y++=*z++; 
    x++; 
    printf("%d %d %d ",x,y,z); 
    return 0; 
} 

Answer 1

Der Ausdruck x = *y++ ist in Effekten gleichen wie:

x = *y; 
y = y + 1; 

Und wenn Ausdruck nur *y++; (ohne Zuordnung) wird dann sein nichts, aber gleich wie y++;, das heißt y Start zur nächsten Position zeigt nach Zuwachs.

Zweiter Ausdruck ++*y bedeutet den Wert von y darauf zu erhöhen, die gleiche wie: *y = *y + 1; (Zeiger nicht erhöht) Es ist mit Antwort auf Ihre erste Frage besser klar sein wird:

Angenommen, Ihr Code:

int x = 30, *y; 
int temp; 
y = &x; 

temp = *y++; //this is same as: temp = *y; y = y + 1; 

Zuerst wird *ytemp Variable zugewiesen; daher temp zugewiesen 30, dann Wert von y erhöht um eins und es Startpunkt zum nächsten Ort nach Ort von x (wo wirklich keine Variable vorhanden ist).

Nächster Fall: Angenommen, Ihr Code:

int x = 30, *y; 
int temp; 
y = &x; 

temp = ++*y; //this is same as *y = *y + 1; temp = *y; 

Erster Wert von *y Schritten 30-31 und dann wird 31-temp zugewiesen (Anmerkung: x ist jetzt 31).

nächster Teil Ihrer Frage (Kommentare lesen):

int x = 30, *y, *z; 

y = &x;  // y ---> x , y points to x 
z = y;  // z ---> x , z points to x 
*y++ = *z++; // *y = *z, y++, z++ , that is 
       // x = x, y++, z++ 
x++;   // increment x to 31 

Answer 2

was ist der Unterschied zwischen * y ++ und ++ * y?

Im Falle der Ausdruck *y++ und *z++; Da die Postfix-Version ++ Vorrang vor * hat, sieht der Compiler dies als;

*(y++) = *(z++); 

Bei ++*y; Compiler sieht dies als ++(*p) und es wird zuerst den Wert des Objekts erhöhen, auf das es zeigt (x in diesem Fall) und dann seinen inkrementierten Wert zurückgeben.

Übersichtstabelle für andere Möglichkeiten;

Expression     Meaning 
------------------------------------------------------------------------------------- 
*y++ or *(y++)   Value of expression is *y before increment; increment y latter 
(*y)++     Value of expression is *y before increment; increment *t later 
*++y or *(++y)   Increment y first; value of expression is *y after increment 
++*y or ++(*y)   Increment *y first; value of expression is *y after increment 

---

EDIT: Wie bereits von Eric Lippert in seinem Kommentar darauf hin, dass den Worten: Wert des Ausdrucks *y vor Schritt ist, erhöhen y später ist irreführend, möchte ich hier klarstellen, dass die Worte, die ich verwendet letztere und nach dass vorherigen oder nächsten Wert von *y zu betonen bzw. wird in Ausdrücken verwendet werden.
Beachten Sie, dass der Nebeneffekt in einer beliebigen Reihenfolge erzeugt werden kann, entweder Nebenprodukt produzieren zuerst und Wert zugewiesen letzteren oder Wert zuerst zugewiesen und Nebeneffekt produzieren letztere. Für weitere Details lesen Sie die Antworten: - 1, 2 gegeben von Eric Lippert.

Answer 3

Ich vertraue darauf, dass Sie verstehen, was die Operatoren ++ und * bedeutet, wenn sie getrennt verwendet werden. Wenn sie zusammen verwendet werden, kommt die Vorrangstellung des Bedieners ins Spiel. In C++ hat der Operator ++ eine höhere Priorität als der Operator *. So effektiv *y++ bedeutet *(y++) und ++y* bedeutet (++y)*. Ich hoffe das hilft.

Answer 4

Was ist der Unterschied zwischen *y++ und ++*y?

Die Bedeutung eines Ausdrucks in C wird durch zwei Dinge aus: was Wert es produziert und welche Nebenwirkungen es produziert.

Lassen Sie uns den ersten Ausdruck untersuchen.

Postfix-Inkrement hat eine höhere Priorität als Dereferenzierung, also ist dies *(y++).

Das Postfixinkrement erzeugt einen Nebeneffekt: Es ändert den Wert y, um auf einen anderen Ort zu zeigen. Das Postfixinkrement erzeugt auch einen Wert: den Wert, den y hatte, bevor er inkrementiert wurde. Der Operator * dereferenziert dann diesen Wert, um einen Lvalue zu erzeugen: das heißt, etwas, das Sie als Variable verwenden können, um entweder zu speichern oder von ihm abzurufen.

Ich bemerke, dass der Nebeneffekt an jedem Punkt vor oder nach der Dereferenzierung auftreten kann. Wenn Sie

sagen

q = *y++ 

dann die Nebenwirkung der ++ an irgendeiner Stelle passieren könnte. Dies könnte:

q = *y; 
y = y + 1; 

oder es könnte als

t = y; 
y = y + 1; 
q = *t; 

Beide sind vollkommen legal behandelt werden. (Außer natürlich, dass, wenn y selbst ein Ausdruck mit Nebenwirkungen ist, diese Nebenwirkungen nur einmal produziert werden müssen. Zur Klarheit werde ich diese Annahme durchweg machen.)

Wie wäre es mit ++*y? Das ist einfach: *y erzeugt eine Variable, der Inhalt der Variablen wird inkrementiert und der Wert des Ausdrucks ist der inkrementierte Wert. Beachten Sie, dass auch hier kann die Nebenwirkung hergestellt werden out-of-order:

q = ++*y 

wie behandelt werden könnten:

t = *y + 1; 
*y = t; 
q = t; 

oder als

t = *y + 1; 
q = t; 
*y = t; 

Denken Sie daran, C nicht produzieren sehr viele Einschränkungen in der Reihenfolge, in denen Nebenwirkungen auftreten können, so sei vorsichtig.