C ++ i ++ vs ++ i

Uno de los muchos operadores en C ++ es el operador de incremento. Se le ocurrió dos formas de ser usado, yo.mi. posterior al incremento y preincremento. Después del incremento implica que el valor de una cierta variable no se incrementará hasta que su último valor se guarde en alguna variable. Mientras que en el método de pre-incremento, el valor de una variable se incrementará primero y luego se guardará en la variable, i.mi. El último valor se habrá ido. Por lo tanto, hemos decidido explicarle y mostrarle el funcionamiento de la implementación del operador de preincremento y posterior al incremento en C ++, i.mi. "++ i" y "i ++". Comencemos a ver algunos ejemplos después de la nueva generación de archivos y al lanzamiento en algún editor, yo.mi. a través de la palabra clave Touch y Nano en el Ubuntu 20.04 concha.

Ejemplo 01:

Comencemos con la ilustración inicial de usar el operador de incremento. En primer lugar, echaremos un vistazo al operador posterior al incremento. Entonces, el código se ha iniciado con el encabezado "IOSTREAM" C ++ y el espacio de nombres "STD" con las palabras "#include" y "usando". Dentro del método main (), un entero "x" se inicializa con 1 e imprime en el terminal con la declaración estándar "cout". Aquí está el operador posterior al incremento para elevar el valor de "x" por 1. Funciona como "x = x+1". Para esto, el valor original de "x" se ha guardado en su variable "x" y después de eso incrementado por 1. El nuevo valor actualizado se imprimirá nuevamente en la consola con "Cout" estándar de C++. El código termina aquí y está listo para ser compilado ahora.

Ubuntu admite el uso de un compilador G ++ para el lenguaje C ++ para compilar el código. Por lo tanto, ya lo hemos instalado y lo estamos utilizando para la compilación de nuestro nuevo script. Va sin problemas, y luego hemos ejecutado el nuevo archivo de código "INCDIC.CC "con el"./a.Fuera ”Ubuntu Instrucción. El valor original 1 de la variable "x" se muestra primero y luego el valor incrementado "2" mediante el uso del operador posterior al incremento en el código.

Presentemos el uso del operador previo al incremento en el código C ++. El operador previo al incremento incrementa el valor original primero y luego lo guarda a la variable. Se han utilizado los mismos encabezados, el mismo espacio de nombres y la misma función principal (). A la variable "x" se le ha asignado un valor de 1. Hemos estado utilizando una declaración de "cout" estándar simple de C ++ para mostrarla. Ahora el operador previo al incremento está aquí junto con la variable "x" para realizar "x = 1 + x". Por lo tanto, el valor de "x" se ha incrementado en 1 y se convierte en 2 usando el operador "++". Después de esto, el nuevo valor se ha guardado en la variable "X" nuevamente e imprimido en el shell con la declaración "Cout". Este código está completo y está listo para ser compilado en el terminal.

Después de esta nueva compilación de código, lo tenemos sin error. Después de usar el "./a.Out "consulta, el valor original de" x "se ha mostrado a continuación, yo.mi. 1. En lo último, el valor preincrementado de "x" también se muestra en el shell, yo.mi. 2.

Ejemplo 02:

Echemos un vistazo a algo nuevo aquí en nuestra ilustración. Entonces, hemos estado comenzando el segundo ejemplo de código C ++ con el mismo espacio de nombres y encabezado "STD", yo.mi. iostream. Al comienzo del método Main () de nuestro código, hemos declarado dos variables de tipo entero, "Y" y "Z". Mientras que la variable "Y" también se ha inicializado, yo.mi. y = 9. Las dos primeras líneas de "Cout" para C ++ están aquí para mostrar los valores originales y primeros de ambas variables. i.mi. y = 9, y z = 0. Ahora, es el turno para que se use el operador. Por lo tanto, hemos estado utilizando el operador posterior al incremento aquí para incrementar el valor de la variable "y" por 1 y guardarlo en la variable "z". Pero, debe comprender que no es tan simple. El operador posterior al incremento "z = y ++" significa que el valor original "9" de la variable "y" se guardará primero en la variable "z". Ahora, la variable "Z" se convierte en 9. Después de esto, el valor de la variable "y" se incrementará en 1 y se convertirá en 10. Cuando mostramos los valores de ambas variables "x" y "y" ahora, nos mostrará los nuevos valores para ambos, yo.mi. "Z = 9" y "y = 10". Compilemos este código ahora.

Después de esta compilación y ejecución de código, ambos valores originales se mostraron en las dos primeras líneas de salida. Las últimas 2 líneas de salida muestran los nuevos valores agregados por el operador posterior al incremento en la variable "Y".

Actualicemos el mismo código para el operador previo al incremento ahora. Dentro del método main (), ambas variables se han declarado igual que nosotros antes, yo.mi. El código no se cambiará excepto la línea de operador de incremento. La "Z = ++ Y" muestra el uso del operador previo al incremento en el código. La declaración "++ y" significa que el valor "9" de la variable "y" se incrementará en 1 primero, yo.mi. convertirse en 10. Después de eso, el nuevo valor se guardaría en la variable "Z" I.mi. Z también se convierte en 10. Las declaraciones de Cout están aquí para mostrar el original y luego los valores incrementados en el shell. Este código está listo para ser utilizado en la terminal.

Este código ha sido compilado y ejecutado después de la actualización. La salida muestra los valores declarados en primer lugar de ambas variables y el valor previo al incremento para ambas variables "x" y "y".

Ejemplo 03:

Tengamos nuestro último ejemplo para este artículo. Hemos comenzado nuevamente nuestro código con el paquete "IOSTream" y el espacio de nombres "STD" de C++. La función Main () se inicializa con la inicialización de una variable entera "I" al valor 5. La cláusula de cout está aquí para mostrar este valor en el shell. Otra variable, "J" se ha inicializado mientras toma valor del posterior al incremento de una variable "I". El último valor de "I" se guardará en la variable "J" I.mi. "J = i = 5". Después de esto, el valor de una variable "i" se incrementará en 1, yo.mi. "I = 5+1". Tanto los nuevos valores para "I" como "J" se imprimirán con "Cout". Una variable "K" se inicializa con el preincrito de la variable "J" ahora. Esto significa que el último valor de "j" se incrementará primero, yo.mi. "J = 5+1 = 6", y luego guardado en la nueva variable "K". Los valores se mostrarán con "Cout". Ahora, es el giro para el uso del operador de doble pulverización previo. El último valor de la variable "k" se incrementa dos veces, yo.mi. "K = 6+1 = 7+1 = 8". Este nuevo valor se guardaría en la nueva variable "L". Tanto los nuevos valores para "K" como "L" se mostrarán en el terminal con la ayuda de la declaración "Cout".

Después de esta ejecución del código, la salida es la misma que se esperaba. Cada paso de incremento se ha demostrado bastante bien en el código y en el shell también.

Conclusión:

Este artículo tiene que ver con la diferencia entre los operadores posteriores al incremento y los operadores previos al incremento en algunas variables mientras lo implementan en Ubuntu 20.04. Este artículo se ha ensamblado secuencialmente, comenzando de ejemplos simples a complicados para una mejor comprensión. Esta forma de explicación única utilizada en nuestro artículo lo hace más atractivo para los estudiantes, estudiantes, programadores y desarrolladores de C ++.