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

Solo un'osservazione casuale, sembra che su StackOverflow.com ci siano domande se "++ i == i ++". Questa domanda viene posta in ogni momento, penso di averla vista fare circa 6 o 7 volte negli ultimi 2 mesi.

Mi chiedo solo perché gli sviluppatori C sono così interessati a questo? Lo stesso concetto / domanda esiste anche per gli sviluppatori C # e Java, ma penso di aver visto solo una domanda relativa a C #.

È perché tanti esempi usano ++ i? È perché c'è qualche libro o tutorial popolare? È perché gli sviluppatori C adorano semplicemente raggruppare il più possibile in un'unica riga per "efficienza" / "prestazioni" e quindi incontrare costrutti "strani" usando l'operatore ++ più spesso?

Sospetto che almeno in parte sia un po 'più semplice: anche adesso vediamo molte domande come questa a partire dall'inizio dell'anno scolastico e gradualmente si assottigliano nel corso dell'anno.

In quanto tale, penso sia giusto indovinare che alcuni di essi sono semplicemente il risultato di lezioni in cui l'insegnante ne parla almeno un po ', ma non spiega molto bene i suoi punti (spesso perché non li capisce davvero da solo). Soprattutto in base alle persone che sembrano porre queste domande, pochi si basano sulla codifica effettiva.

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

Dalla parte superiore della 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 # esperti non hanno idea di quale sia l'output alla Console.

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

In C e C ++, d'altra parte, è quasi indefinito perché dipende dal compilatore, dall'ambiente di esecuzione, dalla piattaforma, ecc., Quindi è una domanda molto più difficile a cui rispondere, quindi molte persone lo fanno.

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

Il link qui sopra va a una FAQ sulla homepage di Bjarnes Stroustrup, che affronta in modo specifico questa domanda e spiega perché questo costrutto non è definito. Quello che dice è:

Fondamentalmente, in C e C ++, se leggi una variabile due volte in un'espressione in cui la scrivi anche tu, il risultato non è definito.

Avere l'ordine di valutazione indefinito è dichiarato per produrre codice con prestazioni migliori.

Molto probabilmente perché in C importa davvero se scrivi i++o ++iquando esegui l'aritmetica del puntatore. Lì, aumentare iprima o dopo un'operazione potrebbe essere cruciale. Ti farei un esempio, ma l'ultima volta che ho scritto C è stato 10 anni fa ...

In C #, non mi sono mai imbattuto in una situazione che mi richiederebbe di pensare i++o ++iperché AFAIK, per i cicli for / while, non importa.

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

Ora è perché alcune persone contorte scrivono loop come

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

Anche ora, non sono troppo sicuro di ciò che accadrà / dovrebbe accadere, ma mi è abbastanza chiaro che più ++ [var] sulla stessa linea sta chiedendo problemi.

Due ragioni.

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

La domanda diventa quindi quando il compilatore li applica durante la valutazione di un'espressione, come l'uguaglianza.

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

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

I test di base elencano ciò per consentire agli sviluppatori di verificare se i loro presupposti sono corretti e se l'implementazione effettiva corrisponde alle specifiche del linguaggio.

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

Penso che sia una cosa shock culturale.

Come già sottolineato, il comportamento di un'espressione in C o C ++ può essere indefinito perché l'ordine di esecuzione dei post-incrementi ecc. Non è definito in modo rigoroso. Il comportamento indefinito è abbastanza comune in C e, naturalmente, molto è stato importato in C ++.

Per qualcuno che ha programmato in un'altra lingua - qualcuno che ha preso l'idea che i linguaggi di programmazione dovrebbero essere precisi e che i computer dovrebbero fare ciò che gli viene detto di fare ... beh, è ​​uno shock scoprire che C è intenzionalmente vago su alcune cose.

Forse è solo che gli sviluppatori C usano l'incremento ++ più spesso in generale, visto che C non ha "foreach" o dichiarazioni simili per iterare attraverso le matrici. Oh, e naturalmente puntatore aritmico, come già accennato!

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

++i

Questo è pre-incremento. Questo pezzo di codice aumenterà prima il valore di iprima di inviare il valore alla riga in cui viene utilizzato.

i++

Questo è l'incremento post. Questo pezzo di codice restituirà il valore di iprima che aumenti il ​​valore dii sulla riga in cui viene 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 sul codepad.

Ciò ha a che fare con l'implementazione interna del sovraccarico dell'operatore.

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

i++crea innanzitutto una copia che viene restituita nel punto in cui è necessario e successivamente il valore originale della ivariabile viene aumentato di uno.

Spero che questo sia chiaro ora.