Operadores Master C de incremento y decremento:uso y mejores prácticas

C - Operadores de incremento y decremento

El operador de incremento (++) incrementa el valor de una variable en 1, mientras que el operador de decremento (--) disminuye el valor.

Los operadores de incremento y decremento se utilizan frecuentemente en la construcción de bucles contados en C (con el bucle for). También tienen su aplicación en el recorrido de la aritmética de matrices y punteros.

Los operadores ++ y -- son unarios y pueden usarse como prefijo o posfijo para una variable.

Ejemplo de operadores de incremento y decremento

El siguiente ejemplo contiene varias declaraciones que demuestran el uso de operadores de incremento y decremento con diferentes variaciones:

#include <stdio.h>
int main() {
 int a = 5, b = 5, c = 5, d = 5;
 
 a++; // postfix increment
 ++b; // prefix increment
 c--; // postfix decrement
 --d; // prefix decrement
 printf("a = %d\n", a);
 printf("b = %d\n", b);
 printf("c = %d\n", c);
 printf("d = %d\n", d);
 return 0;
}

Salida

Cuando ejecute este código, producirá el siguiente resultado:

a = 6
b = 6
c = 4
d = 4

Ejemplo de explicación

En otras palabras, "a++" tiene el mismo efecto que "++a", ya que ambas expresiones incrementan el valor de la variable "a" en 1. De manera similar, "a--" tiene el mismo efecto que "--a".

La expresión "a++;" puede tratarse como el equivalente de la afirmación "a =a + 1;". Aquí, la expresión de la derecha suma 1 a "a" y el resultado se asigna nuevamente a 1, por lo que el valor de "a" se incrementa en 1.

De manera similar, "p--;" es equivalente a "b =b 1;".

Tipos de operador de incremento

Hay dos tipos de operadores de incremento:preincremento y incremento de publicación .

Operador de incremento previo (prefijo)

En una expresión, el operador de preincremento aumenta el valor de una variable en 1 antes de usar el valor de la variable.

Sintaxis

++variable_name;

Ejemplo

En el siguiente ejemplo, utilizamos un operador de preincremento, donde el valor de "x" se incrementará en 1 y luego el valor aumentado se usará en la expresión.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 10 + ++x;
 printf("x = %d, y = %d\n", x, y);
 return 0;
}

Cuando ejecute este código, producirá el siguiente resultado:

x = 11, y = 21

Operador de incremento de publicación (Postfix)

En una expresión, el operador post-incremento aumenta el valor de una variable en 1 después del uso del valor de la variable.

Sintaxis

variable_name++;

Ejemplo

En el siguiente ejemplo, utilizamos el operador de post-incremento, donde el valor de "x" se usará en la expresión y luego se incrementará en 1.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 10 + x++;
 printf("x = %d, y = %d\n", x, y);
 return 0;
}

Cuando ejecute este código, producirá el siguiente resultado:

x = 11, y = 20

Tipos de operador de decremento

Hay dos tipos de operadores de decremento:predecremento y publicar disminución .

Operador de decremento previo (Prefijo)

En una expresión, el operador de pre-decremento disminuye el valor de una variable en 1 antes de usar el valor de la variable.

Sintaxis

--variable_name;

Ejemplo

En el siguiente ejemplo, utilizamos un operador de predecremento, donde el valor de "x" se reducirá en 1 y luego el valor disminuido se utilizará en la expresión.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 10 + --x;
 printf("x = %d, y = %d\n", x, y);
 return 0;
}

Cuando ejecute este código, producirá el siguiente resultado:

x = 9, y = 19

Operador de decremento de publicación (Postfix)

En una expresión, el operador post-decremento disminuye el valor de una variable en 1 después del uso del valor de la variable.

Sintaxis

variable_name--;

Ejemplo

En el siguiente ejemplo, utilizamos el operador post-decremento, donde el valor de "x" se usará en la expresión y luego se reducirá en 1.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 10 + x--;
 printf("x = %d, y = %d\n", x, y);
 return 0;
}

Cuando ejecute este código, producirá el siguiente resultado:

x = 9, y = 20

Más ejemplos de operadores de incremento y decremento

Ejemplo 1

El siguiente ejemplo destaca el uso de incremento/decremento de prefijo/posfijo −

#include <stdio.h>
int main(){
 char a = 'a', b = 'M';
 int x = 5, y = 23;
 printf("a: %c b: %c\n", a, b);
 
 a++;
 printf("postfix increment a: %c\n", a);
 
 ++b;
 printf("prefix increment b: %c\n", b);
 printf("x: %d y: %d\n", x, y);
 
 x--;
 printf("postfix decrement x : %d\n", x);
 
 --y;
 printf("prefix decrement y : %d\n", y);
 return 0;
}

Salida

Cuando ejecute este código, producirá el siguiente resultado:

a: a b: M
postfix increment a: b
prefix increment b: N
x: 5 y: 23
postfix decrement x: 4
prefix decrement y: 22

El ejemplo anterior muestra que los operadores de prefijo y postfijo tienen el mismo efecto en el valor de la variable operando. Sin embargo, cuando estos operadores "++" o "--" aparecen junto con los demás operadores en una expresión, se comportan de manera diferente.

Ejemplo 2

En el siguiente código, los valores iniciales de las variables "a" y "b" son los mismos, pero la función printf() muestra valores diferentes −

#include <stdio.h>
int main(){
 int x = 5, y = 5;
 printf("x: %d y: %d\n", x,y);
 printf("postfix increment x: %d\n", x++);
 printf("prefix increment y: %d\n", ++y);
 return 0;
}

Salida

Ejecute el código y verifique su salida -

x: 5 y: 5
postfix increment x: 5
prefix increment y: 6

En el primer caso, la función printf() imprime el valor de "x" y luego incrementa su valor. En el segundo caso, el operador de incremento se ejecuta primero, la función printf() usa el valor incrementado para imprimir.

Precedencia de operadores de incremento y decremento

Hay varios operadores en C. Cuando se utilizan varios operadores en una expresión, se ejecutan según su orden de precedencia. Los operadores de incremento y decremento se comportan de manera diferente cuando se usan junto con otros operadores.

Cuando una expresión consta de operadores de incremento o decremento junto con otros operadores, las operaciones de incremento y decremento se realizan primero. Los operadores de incremento y decremento de sufijo tienen mayor prioridad que los operadores de incremento y decremento de prefijo.

Lea también: Precedencia del operador en C

Ejemplo 1

Eche un vistazo al siguiente ejemplo:

#include <stdio.h>
int main(){
 int x = 5, z;
 printf("x: %d \n", x);
 z = x++;
 printf("x: %d z: %d\n", x, z);
 return 0;
}

Salida

Ejecute el código y verifique su salida -

x: 5 
x: 6 z: 5

Dado que "x++" incrementa el valor de "x" a 6, es de esperar que "z" también sea 6. Sin embargo, el resultado muestra "z" como 5. Esto se debe a que el operador de asignación tiene una mayor prioridad sobre el operador de incremento de sufijo. Por lo tanto, el valor existente de "x" se asigna a "z", antes de incrementar "x".

Ejemplo 2

Eche un vistazo a otro ejemplo a continuación:

#include <stdio.h>
int main(){
 int x = 5, y = 5, z;
 printf("x: %d y: %d\n", x,y);
 z = ++y;
 printf("y: %d z: %d\n", y ,z);
 return 0;
}

Salida

Cuando ejecute este código, producirá el siguiente resultado:

y: 5
y: 6 z: 6

El resultado puede resultar confuso, ya que el valor de "y" y de "z" ahora es 6. La razón es que el operador de incremento de prefijo tiene mayor prioridad que el operador de asignación. Por lo tanto, "y" se incrementa primero y luego su nuevo valor se asigna a "z".

La asociatividad de los operadores también juega un papel importante. Para los operadores de incremento y decremento, la asociatividad es de izquierda a derecha. Por lo tanto, si hay varios operadores de incremento o decremento en una sola expresión, el operador más a la izquierda se ejecutará primero y se moverá hacia la derecha.

Ejemplo 3

En este ejemplo, la expresión de asignación contiene operadores de prefijo y postfijo.

#include <stdio.h>
int main(){
 int x = 5, y = 5, z;
 z = x++ + ++y;
 printf("x: %d y: %d z: %d\n", x,y,z);
 return 0;
}

Salida

Ejecute el código y verifique su salida -

x: 6 y:6 z: 11

En este ejemplo, la primera operación que se debe realizar es "y++" ("y" se convierte en 6). En segundo lugar, el operador "+" suma "x" (que es 5) e "y", el resultado asignado a "z" como 11, y luego "x++" incrementa "x" a 6.

Usando el operador de incremento en bucle

En C, la sintaxis más utilizada de un bucle for es la siguiente:

for (init_val; final_val; increment) {
 statement(s);
}

Ejemplo

El cuerpo del bucle se ejecuta para todos los valores de una variable entre el valor inicial y el final, incrementándolo después de cada ronda.

#include <stdio.h>
int main(){
 int x;
 for (x = 1; x <= 5; x++){
 printf("x: %d\n", x);
 }
 
 return 0;
}

Salida

Cuando ejecute este código, producirá el siguiente resultado:

x: 1
x: 2
x: 3
x: 4
x: 5