C
Tutorial C: Operadores y expresiones
Descubre cómo usar operadores aritméticos y lógicos en C, desde adiciones hasta jerarquías, esenciales para cualquier programador.
Aprende C y certifícateOperadores 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 tipoint
se suman y devuelven otroint
, mientras que si al menos uno de los operandos es de tipofloat
, 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 afloat
si se desea un resultado con decimales. Por ejemplo,3 / 2
produce1
en variables de tipo entero, mientras que con3.0 / 2
se obtiene1.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,&&
devuelve1
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.
Precedencia | Operador | Descripción | Asociatividad |
---|---|---|---|
1 | () |
Paréntesis | Izquierda a derecha |
1 | [] |
Subíndice | Izquierda a derecha |
1 | . |
Acceso a miembro | Izquierda a derecha |
1 | -> |
Acceso a miembro a través de puntero | Izquierda a derecha |
2 | ++ |
Incremento | Derecha a izquierda |
2 | -- |
Decremento | Derecha a izquierda |
2 | + |
Unario más | Derecha a izquierda |
2 | - |
Unario menos | Derecha a izquierda |
2 | ! |
Negación lógica | Derecha a izquierda |
2 | ~ |
Complemento bit a bit | Derecha a izquierda |
2 | * |
Desreferencia | Derecha a izquierda |
2 | & |
Dirección de | Derecha a izquierda |
2 | sizeof |
Tamaño de | Derecha a izquierda |
2 | (type) |
Conversión de tipo | Derecha a izquierda |
3 | * |
Multiplicación | Izquierda a derecha |
3 | / |
División | Izquierda a derecha |
3 | % |
Módulo | Izquierda a derecha |
4 | + |
Suma | Izquierda a derecha |
4 | - |
Resta | Izquierda a derecha |
5 | << |
Desplazamiento a la izquierda | Izquierda a derecha |
5 | >> |
Desplazamiento a la derecha | Izquierda a derecha |
6 | < |
Menor que | Izquierda a derecha |
6 | <= |
Menor o igual que | Izquierda a derecha |
6 | > |
Mayor que | Izquierda a derecha |
6 | >= |
Mayor o igual que | Izquierda a derecha |
7 | == |
Igual a | Izquierda a derecha |
7 | != |
Diferente de | Izquierda a derecha |
8 | & |
AND bit a bit | Izquierda a derecha |
9 | ^ |
XOR bit a bit | Izquierda a derecha |
10 | ` | ` | OR bit a bit |
11 | && |
AND lógico | Izquierda a derecha |
12 | ` | ` | |
13 | ?: |
Operador ternario | Derecha a izquierda |
14 | = |
Asignación | Derecha a izquierda |
14 | += |
Asignación suma | Derecha a izquierda |
14 | -= |
Asignación resta | Derecha a izquierda |
14 | *= |
Asignación multiplicación | Derecha a izquierda |
14 | /= |
Asignación división | Derecha a izquierda |
14 | %= |
Asignación módulo | Derecha a izquierda |
14 | <<= |
Asignación desplazamiento a la izquierda | Derecha a izquierda |
14 | >>= |
Asignación desplazamiento a la derecha | Derecha a izquierda |
14 | &= |
Asignación AND bit a bit | Derecha a izquierda |
14 | ^= |
Asignación XOR bit a bit | Derecha a izquierda |
14 | ` | =` | Asignación OR bit a bit |
15 | , |
Coma | Izquierda a derecha |
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.
Todas las lecciones de C
Accede a todas las lecciones de C y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.
Introducción A C
Introducción Y Entorno
Primer Programa En C
Introducción Y Entorno
Estructura Básica De Un Programa En C
Sintaxis
Operadores Y Expresiones
Sintaxis
Control De Flujo
Sintaxis
Arrays Y Manejo De Cadenas
Sintaxis
Funciones
Funciones Y Punteros
Punteros
Funciones Y Punteros
Gestión De Memoria Dinámica
Funciones Y Punteros
Estructuras En C
Estructuras, Uniones Y Tipos
Uniones Y Enumeraciones
Estructuras, Uniones Y Tipos
Typedef Y Y Organización De Código
Estructuras, Uniones Y Tipos
Archivos
Io Y Archivos
E/s Binaria Y Formateo
Io Y Archivos
Manipulación Avanzada De Cadenas
Io Y Archivos
En esta lección
Objetivos de aprendizaje de esta lección
- Comprender el uso de operadores aritméticos en C.
- Aplicar operativos lógicos y relacionales en expresiones.
- Diferenciar entre prefijo y sufijo en incrementos y decrementos.
- Identificar jerarquía y asociatividad de operadores.