Operadores aritméticos en C
Los operadores aritméticos en C nos permiten realizar cálculos numéricos con tipos enteros y de punto flotante. En este artículo repasamos cada operador, aclaramos cómo funciona la división entera, y explicamos las conversiones implícitas que C aplica cuando mezclamos tipos distintos tanto en las expresiones aritméticas como en la asignación.
Operadores disponibles
+Suma-Resta (y negación unaria-x)*Multiplicación/División%Módulo (resto de la división entera)
Los operadores binarios +, -, * y / trabajan con enteros y flotantes.
El operador % solo está definido para enteros.
Operaciones con Enteros
Suma, resta, multiplicación y división sin resto operan de manera usual e intuitiva como se muestra en el siguiente ejemplo.
#include <stdio.h>
int main(void)
{
int a = 7, b = 3, c = 6;
printf("a + b = %d\n", a + b); // 10
printf("a - b = %d\n", a - b); // 4
printf("a * b = %d\n", a * b); // 21
printf("c / b = %d\n", c / b); // 2 (división sin resto)
return 0;
}
En el siguiente ejemplo, observa que a / b con enteros produce divisón entera (también conocida como división truncada). El operador % (módulo) muestra el resto de esta división.
int a = 7, b = 3;
printf("a / b = %d\n", a / b); // 2 (división con resto: trunca)
printf("a % b = %d\n", a % b); // 1 (resto)
División entera vs. división en punto flotante
Si al menos uno de los operandos es un número de punto flotante, la operación se convierte al tipo de mayor precisión.
#include <stdio.h>
int main(void)
{
int a = 7, b = 3;
double x = 7.0, y = 3.0;
printf("int/int: %d\n", a / b); // 2
printf("double/double: %.2f\n", x / y); // 2.33
printf("int/double: %.2f\n", a / y); // 2.33 (ver conversiones implícitas)
return 0;
}
Conversiones implícitas en expresiones aritméticas
Cuando una operación aritmética mezcla operandos de distinto tipo, C realiza automáticamente las conversiones habituales aritméticas para no perder precisión: los operandos se “elevan” al tipo con mayor rango/precisión involucrado. En la práctica:
- Si uno de los operandos es de punto flotante (
float/double/long double), ambos se convierten al tipo flotante de mayor precisión presente. - Si ambos son enteros, primero ocurren las promociones de entero (por ejemplo,
charyshortsuelen promoverse aint). Luego, si difieren en tamaño/signo, se convierten a un tipo entero común que pueda representar ambos sin pérdida cuando sea posible.
#include <stdio.h>
int main(void)
{
int i = 5;
float f = 2.0f;
double d = 2.0;
// i + f: i se convierte a float, el resultado es float
float rf = i + f; // 7.0f
// i + d: i se convierte a double, el resultado es double
double rd = i + d; // 7.0
printf("rf=%.1f, rd=%.1f\n", rf, rd);
return 0;
}
Asignación y conversiones implícitas
Además de las conversiones en las expresiones, cuando asignas el resultado a una variable, el valor se convierte implícitamente al tipo de la variable destino. Esto puede truncar parte fraccionaria o ajustar el rango.
#include <stdio.h>
int main(void)
{
double d = 3.9;
int i = d; // conversión implícita: i guarda 3 (truncado)
printf("i = %d\n", i);
int big = 1000000;
float fx = big; // posible pérdida de precisión en float
printf("fx = %.0f\n", fx);
// Para forzar el tipo del resultado de una expresión, usa casting:
int a = 7, b = 3;
double r1 = (double)a / b; // 2.333..., al convertir a double antes de dividir
double r2 = a / (double)b; // idem
double r3 = (double)(a / b); // 2.0, ¡cuidado! aquí la división fue entera antes del cast
printf("r1=%.2f r2=%.2f r3=%.1f\n", r1, r2, r3);
return 0;
}
Operadores de asignación compuesta
C ofrece atajos que combinan operación aritmética y asignación, aplicando las mismas reglas de conversión en el resultado final:
+=,-=,*=,/=,%=
#include <stdio.h>
int main(void)
{
int x = 10;
x += 2.8; // x = (int)(x + 2.8) -> 12 (parte fraccionaria se pierde al asignar)
printf("x = %d\n", x);
return 0;
}