Cosa rende gli sviluppatori C così curiosi se "i ++ == ++ i"? [chiuso]

Sospetto che almeno una parte di esso sia un po 'più semplice: anche ora, vediamo un sacco di domande come questa a partire dall'inizio dell'anno scolastico, che gradualmente si assottigliano durante l'anno.

Come tale, penso che sia giusto intuire che alcuni di essi sono semplicemente il risultato di lezioni in cui l'insegnante ne parla almeno un po ', ma non spiega molto bene il suo punto (come spesso perché non li capisce davvero da solo). Soprattutto in base alle persone che sembrano porre queste domande, poche sono basate su una vera codifica.

Perché i programmatori C DEVONO capire l'ordine delle operazioni. Gli sviluppatori C # non usano necessariamente gli operatori bitwise (& amp ;, |, ~) o gli operatori di prefissi poiché normalmente siamo più preoccupati di altre cose. Tuttavia, ciò che noi sviluppatori di C # non capiamo è che dovremmo sapere cosa fanno gli operatori che facciamo quotidianamente e come usarli correttamente. La maggior parte di noi evita solo i luoghi in cui questo potrebbe essere un problema.

Fuori dalla tua testa, qual è l'output di questo frammento?

    double x = 5.5;
    Console.WriteLine(x++);
    x = 5.5;
    Console.WriteLine(++x);

Direi che un buon numero di sviluppatori C # non ha idea di cosa sia l'output per la console.

Penso che questo sia ovvio. In C #, per un int i , i++ == ++i è sempre falso mentre ++i == i++ è sempre true, affidabile, e chiunque sia interessato può scoprirlo facilmente solo imparando le regole di C # (o in effetti semplicemente eseguendolo).

In C e C ++, d'altro canto, è vicino a undefined perché dipende dal compilatore, dall'ambiente di esecuzione, dalla piattaforma, ecc., quindi è una domanda molto più difficile da rispondere, quindi molte persone lo chiedono.

Molto probabilmente perché in C, è davvero importante scrivere i++ o ++i quando si esegue l'aritmetica del puntatore. Qui, aumentare il i prima o dopo un'operazione potrebbe essere cruciale. Ti darei un esempio ma l'ultima volta che ho scritto C era 10 anni fa ...

In C #, non mi sono mai imbattuto in una situazione che mi richiederebbe di pensare a i++ o ++i perché AFAIK, per i cicli for / while, non ha molta importanza.

È una domanda popolare perché è una domanda trabocchetto. Non è definito .

Il link sopra riportato fa riferimento a una FAQ sulla homepage di Bjarnes Stroustrup, che affronta specificamente questa domanda e spiega perché questo costrutto non è definito. Quello che dice è:

Basically, in C and C++, if you read a variable twice in an expression where you also write it, the result is undefined.

Having the order of evaluation undefined is claimed to yield better performing code.

Alcuni anni fa ho letto che questi operatori erano considerati pericolosi, quindi ho provato a scavare più informazioni su di esso. Se lo stackoverflow fosse stato attivo in quel momento, lo avrei richiesto lì.

Ora è perché alcune persone contorte scrivono loop come

while( [something] )
{
  a[++j] = ++j;
}

Anche adesso, non sono troppo sicuro di cosa succederà / dovrebbe accadere, ma è abbastanza chiaro per me che più ++ [var] sulla stessa linea sta chiedendo dei problemi.

Due motivi.

L'implementazione corretta di ++ i è quella di incrementare i e quindi restituirlo. L'implementazione corretta di i ++ consiste nel salvare il valore corrente, incrementare i e restituire il valore salvato. Sapere che questi non sono implementati come sinonimi è importante.

La domanda diventa quando il compilatore le applica durante la valutazione di un'espressione, ad esempio l'uguaglianza.

Se il test di uguaglianza viene eseguito per primo, quindi gli operatori di pre e post-incremento, dovrai scrivere una logica diversa rispetto a quando vengono valutati il lato sinistro (lhs) e il lato destro (rhs) prima, poi l'uguaglianza.

Riguarda l'ordine delle operazioni e ciò a sua volta influisce sul codice che uno scrive. E, non troppo sorprendentemente, non tutte le lingue sono d'accordo.

Elenco test di base che consente agli sviluppatori di verificare se le loro ipotesi sono corrette, nonché se l'implementazione effettiva corrisponde alle specifiche della lingua.

Questo può avere tutti i tipi di impatto quando si lavora con puntatori, loop o valori di ritorno.

Penso che sia una cosa da shock culturale.

Come già sottolineato, il comportamento di un'espressione in C o C ++ può essere indefinito perché l'ordine di esecuzione degli incrementi post ecc non è strettamente definito. Il comportamento indefinito è piuttosto comune in C, e ovviamente molto è stato importato in C ++.

A qualcuno che ha fatto un po 'di programmazione in un'altra lingua - qualcuno che ha capito che i linguaggi di programmazione dovrebbero essere precisi e che i computer dovrebbero fare ciò che gli viene detto di fare ... beh, è uno shock per scoprire che C è intenzionalmente vago su alcune cose.

Forse è solo che gli sviluppatori C usano l'incremento di ++ più spesso in generale - visto che C non ha "foreach" o istruzioni simili per iterare attraverso gli array. Oh, e ovviamente puntatore aritmetico, come accennato in precedenza!

La differenza tra le due parti: il post e il preincremento stanno funzionando nel modo in cui queste due parti di codice dovrebbero funzionare in ogni lingua. QUESTO NON E 'DIPENDENTE DA LINGUA !!!

++i

Questo è pre incremento. Questo pezzo di codice aumenterà prima il valore di i prima che invii il valore alla riga in cui è utilizzato.

i++

Questo è l'incremento del post. Questo pezzo di codice restituirà il valore di i prima di aumentare il valore di i sulla riga in cui è utilizzato.

In un altro piccolo esempio:

int main(void)
{
  int i = 0; 
  int result; 
  result = 10 + ++i; 
  printf("%d \n", result); // = 11 

  int j = 0; 
  result = 10 + j++; 
  printf("%d \n", result);// = 10
  return 0;
}

Questo codice viene compilato con risultati su codepad.

Questo ha a che fare con l'implementazione interna dell'overloading dell'operatore.

++i aumenta direttamente il valore (ed è quindi un po 'più veloce)

i++ prima crea una copia che viene restituita al posto dove necessario e in seguito il valore originale della variabile i viene aumentato di uno.

Spero che ora sia chiaro.