Operadores aritméticos

En C, las operaciones aritméticas se implementan utilizando operadores que permiten sumar, restar, multiplicar, dividir y obtener el resto de una división. Estos operadores pueden aplicarse tanto a variables enteras como a variables de punto flotante, siempre respetando las reglas de conversión entre tipos.

• El operador + se utiliza para sumar valores de cualquier tipo numérico. Por ejemplo, dos variables de tipo int se suman y devuelven otro int, mientras que si al menos uno de los operandos es de tipo float, el resultado será flotante. Un uso frecuente consiste en acumular resultados en un bucle u operar con contadores.
• El operador - funciona de forma similar a +, pero para restar valores numéricos. Además de su uso binario, también se utiliza de manera unaria para indicar un número negativo. Con frecuencia, se combina con las demás operaciones para expresar cálculos más complejos.
• Para la multiplicación, se emplea el operador *, que puede utilizarse tanto con enteros como con flotantes. Resulta útil en aplicaciones que requieran múltiples productos intermedios, y es común verlo junto a operaciones de incremento para optimizar cálculos de índices u offset en memoria.
• El operador / realiza la división. Cuando ambos operandos son de tipo entero, el resultado se trunca a un valor entero sin redondeo; por este motivo, suele ser necesaria la conversión a float si se desea un resultado con decimales. Por ejemplo, 3 / 2 produce 1 en variables de tipo entero, mientras que con 3.0 / 2 se obtiene 1.5.
• Para obtener el resto de una división entera, se emplea el operador %. Este operador devuelve el residuo de dividir un primer operando entre un segundo operando, y se aplica exclusivamente a tipos enteros. Suele utilizarse para verificar divisibilidad o para extraer cifras en operaciones numéricas específicas.

La siguiente demostración ilustra los operadores aritméticos en un bloque de código conciso:

#include <stdio.h>

int main(void) {
    int x = 10, y = 3;
    float z = 3.5;

    printf("Suma: %d\n", x + y); // 13
    printf("Resta: %d\n", x - y); // 7
    printf("Multiplicación: %d\n", x * y); // 30
    printf("División entera: %d\n", x / y); // 3
    printf("División flotante con dos decimales: %.2f\n", x / z); // 2.86
    printf("Módulo: %d\n", x % y); // 1

    return 0;
}

En los ejemplos anteriores, la precisión de cada operación depende del tipo de dato que interviene. Por ello, conviene prestar atención a las conversiones implicadas para evitar pérdidas de información cuando se mezclan tipos enteros y flotantes.

Operadores lógicos y relacionales

Los operadores lógicos y relacionales en C permiten evaluar expresiones que comparan valores y determinan condiciones para la toma de decisiones. Mediante estos operadores, se genera un resultado de tipo entero donde 0 suele representar que la comparación no se cumple y un valor distinto de cero indica que la comparación es verdadera.

• El operador relacional == comprueba si dos expresiones son iguales, mientras que != indica si son distintas. Por otro lado, < y > permiten verificar si un valor es menor o mayor que otro respectivamente. Estas comparaciones se aplican a variables de tipo numérico y resultan esenciales para controles y validaciones con rangos concretos.
• Los operadores lógicos && (AND) y || (OR) combinan varias condiciones para producir un resultado unificado. En particular, && devuelve 1 si todas las expresiones son verdaderas, y || se satisface si al menos una expresión es verdadera. Es habitual encontrar estos operadores anidados para reflejar múltiples condiciones en una sola sentencia.

A continuación se muestra un ejemplo que aplica estos operadores en diferentes comparaciones:

#include <stdio.h>

int main(void) {
    int x = 5, y = 2;

    printf("x == 5: %d\n", x == 5); // 1
    printf("x != 5: %d\n", x != 5); // 0
    printf("x > y: %d\n", x > y); // 1
    printf("(x > 0 && y > 0): %d\n", (x > 0 && y > 0)); // 1
    printf("(x < 0 || y < 0): %d\n", (x < 0 || y < 0)); // 0

    return 0;
}

En el ejemplo, cada comparación mostrará un entero (0 o 1) según se cumpla o no la condición evaluada. Es recomendable revisar cómo influyen los tipos de datos en estas operaciones cuando se trabaja con enteros y valores de punto flotante para evitar resultados inesperados.

Operadores de incremento y decremento

Los operadores de incremento(++) y decremento(--) se utilizan para modificar el valor de una variable entera de forma compacta. Mediante ++, se aumenta el valor en una unidad; con --, se disminuye una unidad. Estos operadores son frecuentes al trabajar con contadores o en contextos donde se requiere actualizar una variable de manera repetitiva.

La ubicación del operador (prefijo o sufijo) define el momento en el que se aplica el cambio. Usar ++x o --x (prefijo) afecta la variable antes de que se evalúe la expresión completa. Por su parte, x++ o x-- (sufijo) emplea primero el valor original de la variable y luego realiza el incremento o decremento al finalizar la evaluación. Esta distinción influye en el valor devuelto por la expresión que contiene el operador, por lo que conviene prestar atención a cómo se encadena con otras instrucciones.

Es recomendable usar la notación que aporte mayor claridad en cada situación. Por ejemplo, ++x puede hacer el código más explícito si se desea actualizar el valor antes de emplearlo en otra parte de la expresión, mientras que x++ resulta útil cuando se precisa la versión previa de la variable en un cálculo intermedio.

A continuación se muestra un ejemplo ilustrativo:

#include <stdio.h>

int main(void) {
    int x = 5;

    printf("Valor inicial de x: %d\n", x); // 5
    printf("Resultado de x++: %d\n", x++); // 5
    printf("Después de x++: %d\n", x); // 6
    printf("Resultado de ++x: %d\n", ++x); // 7
    printf("Después de ++x: %d\n", x); // 7

    return 0;
}

En este ejemplo, se puede observar cómo la diferencia entre x++ y ++x afecta tanto a la evaluación inmediata de la expresión como al nuevo valor de la variable. Un criterio habitual es mantener la consistencia en todo el programa para evitar confusiones y mejorar la legibilidad.

Jerarquía y asociatividad de operadores

En C, la jerarquía de operadores determina qué partes de una expresión se evalúan primero cuando se combinan varios operadores. Esta organización evita ambigüedades y hace que ciertas operaciones tengan prioridad sobre otras, aunque en muchos casos se recurre a los paréntesis para dejar clara la intención del programador.

La asociatividad describe el orden en el que se evaluarán los operadores de la misma precedencia. Por convención, la mayoría de los operadores binarios en C tienen asociatividad de izquierda a derecha, de modo que las expresiones se resuelven en esa dirección. Por ejemplo, si se combina el operador - varias veces sin paréntesis, se evaluará de izquierda a derecha de forma secuencial.

Las categorías de precedencia agrupan a operadores como * y / por encima de + y -, lo que asegura que las multiplicaciones y divisiones se realicen antes en una misma expresión sin paréntesis. La evaluación también se aplica a otros operadores que, aunque no se repasan aquí de forma detallada, siguen las mismas reglas de jerarquía.

Una práctica frecuente al programar es utilizar paréntesis para dejar clara la ordenación de las operaciones cuando la expresión resulte compleja. Esto no solo reduce errores, sino que mejora la legibilidad. Por ejemplo, en una expresión como a + b * c, C primero evalúa b * c y luego realiza a + (resultado), pero se pueden añadir paréntesis para dejar explícito: (a + b) * c o a + (b * c).

Cuando se emplean operadores unarios como ++x o --x en expresiones más amplias, puede ser útil recordar que su precedencia es superior a la de las operaciones aritméticas de suma y resta. Además, el uso de estos operadores en forma prefijo o sufijo puede alterar el valor inmediato que se emplea en el cálculo, por lo que conviene confirmar el orden de evaluación consultando la tabla oficial de precedencias.

El siguiente fragmento muestra una expresión con distintos operadores donde la importancia de la jerarquía y la asociatividad se hace evidente:

#include <stdio.h>

int main(void) {
    int x = 2, y = 3, z = 4;
    int resultado = x + y * z - ++y;

    printf("Resultado: %d\n", resultado); // 10
    printf("Nuevo valor de y: %d\n", y); // 4

    return 0;
}

En este ejemplo, el operador * tiene mayor prioridad que + o -, y el operador ++ (en modo prefijo) se aplica a y antes de evaluar el resto de la expresión. Como norma general, es recomendable revisar la lista de precedencia y asociatividad en la documentación oficial cuando surjan dudas, especialmente si se combinan muchos operadores en la misma instrucción.