C ++ i ++ vs ++ i

Uno dei tanti operatori in C ++ è l'operatore di incremento. Ha trovato due modi per essere usati, io.e. post-incremento e pre-incremento. Post-incremento implica che il valore di una determinata variabile non sarà incrementato fino a quando il suo ultimo valore non sarà salvato a una variabile. Mentre nel metodo di pre-incremento, il valore di una variabile verrà incrementato per primo e quindi salvato alla variabile, i.e. L'ultimo valore sparirà. Pertanto, abbiamo deciso di spiegarti e mostrarti il ​​funzionamento dell'implementazione dell'operatore pre-incremento e post-incremento in C ++, i.e. "++ i" e "i ++". Cominciamo a guardare alcuni esempi dopo la nuova generazione di file e lancio in alcuni editor, io.e. tramite la parola chiave touch e nano su Ubuntu 20.04 Shell.

Esempio 01:

Iniziamo con l'illustrazione iniziale dell'utilizzo dell'operatore di incremento. In primo luogo, daremo un'occhiata all'operatore post-incremento. Quindi, il codice è stato avviato con header "iostream" C ++ e spazio dei nomi "STD" con le parole "#include" e "usare". All'interno del metodo principale (), un numero intero "x" viene inizializzato con 1 e stampato nel terminale con l'istruzione standard "cout". Ecco l'operatore post-incremento per aumentare il valore di "x" di 1. Funziona come "x = x+1". Per questo, il valore originale di "x" è stato salvato nella sua variabile "x" e successivamente incrementato di 1. Il nuovo valore aggiornato verrà nuovamente stampato sulla console con "cout" standard di C++. Il codice termina qui ed è pronto per essere compilato ora.

Ubuntu supporta l'uso di un compilatore G ++ per il linguaggio C ++ per compilare il codice. Pertanto, l'abbiamo già installato e lo stiamo usando per la compilazione del nostro nuovo script. Passa senza intoppi e quindi abbiamo eseguito il nuovo file di codice "INCDIC.cc "con il"./UN.fuori ”istruzioni ubuntu. Il valore 1 originale della variabile "x" viene visualizzato per primo e quindi il valore incrementato "2" mediante l'uso dell'operatore post-incremento nel codice.

Elenchiamo l'utilizzo dell'operatore pre-incremento nel codice C ++. L'operatore di pre-incremento incrementa prima il valore originale e quindi lo salva alla variabile. Sono state utilizzate le stesse intestazioni, lo stesso spazio dei nomi e la stessa funzione principale (). Alla variabile "x" è stato assegnato un valore di 1. Abbiamo usato una semplice dichiarazione standard "cout" di C ++ per visualizzarla. Ora l'operatore pre-incremento è qui insieme alla variabile "x" per eseguire "x = 1 + x". Pertanto, il valore di "x" è stato incrementato di 1 e diventa 2 usando l'operatore "++". Dopo questo, il nuovo valore è stato salvato di nuovo nella variabile "X" e stampato sulla shell con l'istruzione "Cout". Questo codice è completo e pronto per essere compilato sul terminale.

Dopo questa nuova raccolta di codice, abbiamo ottenuto senza errori. Dopo aver usato il "./UN.query out ", il valore originale di" x "è stato visualizzato di seguito, i.e. 1. Infine, il valore pre-incrementato di "x" viene visualizzato anche sulla shell, i.e. 2.

Esempio 02:

Diamo un'occhiata a qualcosa di nuovo qui nella nostra illustrazione. Quindi, abbiamo iniziato il secondo esempio di codice C ++ con lo stesso spazio dei nomi e intestazione "std", i.e. iostream. All'inizio del metodo principale () del nostro codice, abbiamo dichiarato due variabili di tipo intero, "Y" e "Z". Mentre anche la variabile "y" è stata inizializzata, io.e. y = 9. Le prime due linee "cout" per C ++ sono qui per visualizzare i valori originali e primi di entrambe le variabili. io.e. y = 9 e z = 0. Ora è il turno per l'uso dell'operatore. Quindi, abbiamo usato l'operatore post-incremento qui per aumentare il valore della variabile "Y" di 1 e salvarlo nella variabile "Z". Ma devi capire che non è così semplice. L'operatore post-incremento "z = y ++" indica che il valore originale "9" di variabile "y" verrà salvato nella variabile "z" prima. Ora, la variabile "z" diventa 9. Successivamente, il valore della variabile "y" sarà incrementato di 1 e diventerà 10. Quando visualizziamo i valori di entrambe le variabili "x" e "y" ora, ci mostrerà i nuovi valori per entrambi, io.e. "Z = 9" e "Y = 10". Compiliamo questo codice ora.

Dopo questa compilazione ed esecuzione del codice, entrambi i valori originali sono stati visualizzati nelle prime due righe di output. Le ultime 2 righe di output mostrano i nuovi valori aggiunti dall'operatore post-incremento su "Y" variabile.

Aggiorniamo ora lo stesso codice per l'operatore pre-incremento. All'interno del metodo principale (), entrambe le variabili sono state dichiarate uguali come facevamo prima, io.e. Il codice non verrà modificato tranne la riga dell'operatore di incremento. La "z = ++ y" mostra l'utilizzo dell'operatore pre-incremento nel codice. L'istruzione "++ y" significa che il valore "9" di variabile "y" sarà incrementato per 1 primo, i.e. diventare 10. Successivamente, il nuovo valore verrebbe salvato alla variabile "Z" i.e. Z diventa anche 10. Le istruzioni Cout sono qui per visualizzare l'originale e quindi i valori incrementati sulla shell. Questo codice è pronto per essere utilizzato sul terminale.

Questo codice è stato compilato ed eseguito dopo l'aggiornamento. L'output mostra i valori prima dichiarati di entrambe le variabili e il valore pre-incremento per entrambe le variabili "x" e "y".

Esempio 03:

Facciamo il nostro ultimo esempio per questo articolo. Abbiamo nuovamente avviato il nostro codice con il pacchetto "iostream" e lo spazio dei nomi "std" di c++. La funzione principale () è inizializzata con l'inizializzazione di una variabile intera "i" al valore 5. La clausola Cout è qui per visualizzare questo valore sulla shell. Un'altra variabile, "J" è stata inizializzata durante l'assunzione di valore dalla post-incremento di una variabile "I". L'ultimo valore di "i" verrà salvato nella variabile "j" i.e. "J = i = 5". Successivamente, il valore di una variabile "i" sarà incremento di 1, i.e. "I = 5+1". Sia i nuovi valori per "io" che "j" saranno stampati con "cout". Una "k" variabile viene inizializzata con la pre-incremento della variabile "j" ora. Ciò significa che l'ultimo valore di "j" sarà incrementato per primo, i.e. "J = 5+1 = 6", quindi salvato alla nuova variabile "K". I valori verranno visualizzati con "cout". Ora è il turno per l'utilizzo dell'operatore pre-incremento a doppio pre-incremento. L'ultimo valore della variabile "k" è incrementato due volte, i.e. "K = 6+1 = 7+1 = 8". Questo nuovo valore verrebbe salvato nella nuova variabile "L". Sia i nuovi valori per "K" e "L" verranno mostrati nel terminale con l'aiuto dell'affermazione "Cout".

Dopo questa esecuzione del codice, l'output è lo stesso del previsto. Ogni fase di incrementazione è stata dimostrata abbastanza bene nel codice e anche sulla shell.

Conclusione:

Questo articolo riguarda la differenza tra operatori post-incremento e operatori di pre-incremento su alcune variabili mentre lo implementano su Ubuntu 20.04. Questo articolo è stato assemblato in sequenza, a partire da esempi semplici a complicati per una migliore comprensione. Questo modo unico di spiegazione utilizzato nel nostro articolo lo rende più attraente per studenti, studenti, programmatori e sviluppatori C ++.