Pre incremento vs Incremento post nell'array

Question

Sto imparando la programmazione e ho iniziato dal linguaggio C. Stavo leggendo Let us C book. E stavo passando attraverso questo programma in quel libro.

main() 
{ 
int a[5] = { 5, 1, 15, 20, 25 } ; 
int i, j, k = 1, m ; 
i = ++a[1] ; 
j = a[1]++ ; 
m = a[i++] ; 
printf ("\n%d %d %d", i, j, m) ; 
} 

La mia comprensione era, verrà stampata i as 2, j as 1 e m as 15

Ma in qualche modo è come la stampa i as 3, j as 2 e m as 15? Perché è così?

Qui di seguito è il mio understanding-

b = x++; 
In this example suppose the value of variable ‘x’ is 5 then value of variable ‘b’ will be 5 because old value of ‘x’ is used. 

b = ++y; 
In this example suppose the value of variable ‘y’ is 5 then value of variable ‘b’ will be 6 because the value of ‘y’ gets modified before using it in a expression. 

qualcosa che non va nella mia comprensione?

Answer 1

Hai colpito l'unghia sulla testa. La tua comprensione è corretta. La differenza tra le espressioni di pre e post incremento è proprio come sembra. Pre-incremento significa che la variabile viene incrementata prima che l'espressione sia impostata o valutata. Post-incremento significa che l'espressione è impostata o valutata, e quindi la variabile è alterata. È facile pensarlo come un processo in due fasi.

b = x++; 

è davvero:

b = x; 
x++; 

e

b = ++x; 

è davvero:

x++; 
b = x; 

EDIT: La parte difficile degli esempi che hai fornito (che probabilmente ha gettato spento) è che c'è un'enorme differenza tra un indice di array e il suo valore.

i = ++a[1]; 

Ciò significa incremento del valore memorizzato ad un [1], e quindi impostare alla variabile i.

m = a[i++]; 

Questo significa impostare m sul valore di un [i], quindi incrementare i. La differenza tra i due è una distinzione piuttosto grande e può inizialmente creare confusione.

Secondo EDIT: scomposizione del codice

{ 
int a[5] = { 5, 1, 15, 20, 25 } ; 
int i, j, k = 1, m ; 
i = ++a[1] ; 
j = a[1]++ ; 
m = a[i++] ; 
printf ("\n%d %d %d", i, j, m) ; 
} 

Prima:

i = ++a[1]; 

A questo punto sappiamo un [1] = 1 (ricordare array sono pari a zero indicizzata). Ma lo incrementiamo prima. Pertanto i = 2.

j = a[1]++; 

Ricorda abbiamo incrementato di un [1] prima, quindi è attualmente 2. Abbiamo impostato j = 2, e poi aumentato a 3. Quindi, j = 2 e ora un [1] = 3.

m = a[i++]; 

sappiamo i = 2. quindi abbiamo bisogno di impostare m = a [2], e quindi incrementare i. Alla fine di questa espressione, m = 15 e i = 3.

In sintesi,

i = 3, j = 2, m = 15. 

Answer 2

tua comprensione non è esattamente corretto. Gli operatori di pre-incremento e post-incremento sono operatori unari.

Quindi, inizialmente se b = 5, quindi ++ b o b ++ incrementa il valore di b a 6. Tuttavia, la differenza tra pre e post viene quando si utilizza un operatore di assegnazione "=".

Quindi,

if b=5 
a=b++ // after this statement a=5 and b=6 as it is post increment 
c=++b // after this statement c=7 and b=7 

Per una chiara comprensione, è possibile dividere le dichiarazioni di cui sopra come:

a=b; 
b=b+1; //post increment 
b=b+1; //pre increment 
c=b;` 

Così, l'esempio che ha dato:

main()  
{  
int a[5] = { 5, 1, 15, 20, 25 } ;  
int i, j, k = 1, m ; 
i = ++a[1] ; // a[1] = 2 and i = 2 
j = a[1]++ ; // j = 2 and a[1] = 3 
m = a[i++] ; // m = a[2++] = 15, i now becomes 3 
printf ("\n%d %d %d", i, j, m) ; // so i =3, j= 2 and m =15 
} 

Per chiarezza, io Sto suddividendo il codice sopra in più istruzioni:

main()  
{  
int a[5] = { 5, 1, 15, 20, 25 } ;  
int i, j, k = 1, m ; 
a[1] = a[1] + 1; 
i = a[1]; 
j = a[1]; 
a[1] = a[1] + 1; 
m = a[i]; // m = a[2] = 15 
i = i + 1; 
printf ("\n%d %d %d", i, j, m) ; // so i =3, j= 2 and m =15 
} 

Spero che la spiegazione sopra chiarisca il tuo dubbio e l'output del programma che stai utilizzando.

Answer 3

Spiegazione:

Fase 1: int a [5] = {5, 1, 15, 20, 25}; L'arr variabile viene dichiarata come array intero con una dimensione di 5 e viene inizializzato a [0] = 5, un [1] = 1, a [2] = 15, a [3] = 20, un [4 ] = 25.

Passaggio 2: int i, j, m; Le variabili i, j, m sono dichiarate come un tipo intero.

Passaggio 3: i = ++ a [1]; diventa i = ++ 1; Quindi i = 2 e a [1] = 2

Passaggio 4: j = a [1] ++; diventa j = 2 ++; Quindi j = 2 ed un [1] = 3.

Fase 5: m = a [i ++]; diventa m = a [2]; Quindi m = 15 e i viene incrementato di 1 (i ++ significa 2 ++ così i = 3)

Fase 6: printf ("% d,% d,% d", i, j, m); Esso stampa il valore delle variabili i, j, m

qui l'output del programma è 3, 2, 15