differenza tra * y ++ e ++ * y?

Question

Sono confuso su come verrà eseguito questo codice. Supponiamo di avere

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

qual è la differenza tra * y ++ e ++ * y? e anche quale sarà l'output di questo programma?

#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

L'espressione x = *y++ è in effetti lo stesso esempio:

x = *y; 
y = y + 1; 

E se l'espressione è solo *y++; (senza assegnazione) allora il suo nulla, ma uguale a y++;, che è y inizio indicando posizione successiva dopo incremento.

seconda espressione ++*y significa incrementare il valore puntato da y stesso come: *y = *y + 1; (non puntatore incrementato) Sarà meglio chiari con risposta alla tua prima domanda:

Supponiamo che il vostro codice è:

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

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

Il primo *y sarà assegnato alla variabile temp; quindi temp assegnato 30, quindi il valore di incrementi di di uno e si avvia il punto alla posizione successiva dopo la posizione di x (dove in realtà non è presente alcuna variabile).

caso successivo: Supponiamo che il vostro codice è:

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

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

Primo valore del *y incrementi 30-31 e poi 31 è assegnato a temp (nota: x è ora 31).

prossima parte della tua domanda (leggi i commenti):

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

qual è la differenza tra * y ++ e ++ * y?

In caso di espressione *y++ e *z++; poiché la versione postfix ++ ha la precedenza su *, il compilatore lo vede come;

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

In caso di ++*y; il compilatore lo vede come ++(*p) e in primo luogo incrementerà il valore dell'oggetto a cui punta (x in questo caso) e quindi restituirà il suo valore incrementato.

Tabella riassuntiva per altre possibilità;

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: Come sottolineato dalla Eric Lippert nel suo commento che diceva: il valore di espressione è *y prima incremento, incrementare y tardi è fuorviante, voglio chiarire qui che le parole che ho utilizzato quest'ultimo e dopo sottolineare che precedente o prossima valore *y, rispettivamente, essere usato nelle espressioni
Si noti che, l'effetto collaterale può essere prodotto in qualsiasi ordine, sia l'effetto collaterale prodotto per primo e il valore assegnato quest'ultimo o il valore assegnato per primo e l'effetto collaterale posteriore. Per maggiori dettagli leggi le risposte: - 1, 2 dato da Eric Lippert.

Answer 3

Confido che tu capisca cosa significano gli operatori ++ e * se usati separatamente. Se utilizzati insieme, entra in gioco la precedenza dell'operatore. In C++ l'operatore ++ ha una precedenza maggiore rispetto all'operatore *. Così efficacemente *y++ significa *(y++) e ++y* significa (++y)*. Spero che aiuti.

Answer 4

Qual è la differenza tra *y++ e ++*y?

Il significato di un'espressione in C è caratterizzato da due cose: ciò valore produce e quali effetti collaterali che produce.

Esaminiamo la prima espressione.

L'incremento postfisso ha una priorità più alta del dereferenziamento, quindi questo è *(y++).

L'incremento postfisso produce un effetto collaterale: modifica il valore di y in modo che punti a un'altra posizione. L'incremento postfisso produce anche un valore: il valore che aveva prima di essere incrementato. L'operatore * quindi denota quel valore per produrre un lvalue: cioè, qualcosa che è possibile utilizzare come variabile, da memorizzare o da cui recuperare.

Ho notato che l'effetto collaterale può verificarsi in qualsiasi momento prima o dopo il dereferenziamento. Se lei ha detto

q = *y++ 

quindi l'effetto collaterale della ++ potrebbe accadere in qualsiasi momento. Questo potrebbe essere:

q = *y; 
y = y + 1; 

o potrebbe essere trattato come

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

Entrambi sono perfettamente legale. (Tranne naturalmente che se lo è esso stesso un'espressione con effetti collaterali, quegli effetti collaterali devono essere prodotti solo una volta. Per chiarezza, farò questa ipotesi per tutto il tempo.)

Che ne dici di ++*y? È semplice: *y produce una variabile, il contenuto della variabile viene incrementato e il valore dell'espressione è il valore incrementato. Si noti che di nuovo, l'effetto collaterale può essere prodotto fuori ordine:

q = ++*y 

potevano essere considerati:

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

o come

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

Ricordare, C non produrre molte restrizioni sull'ordine in cui possono verificarsi effetti collaterali, quindi fai attenzione.