Operadores aritméticos y lógicos en C

Bienvenidos al cuarto de máquinas. Hoy aprenderemos a procesar la información.

En C, un operador es un símbolo especial que le dice al compilador que realice una manipulación matemática o lógica específica. Aunque muchos te resultarán familiares de tus clases de álgebra, C tiene “trampas” y reglas ocultas que, si no conoces, pueden tirar abajo un puente o estrellar un satélite.

Dividiremos esto en tres categorías vitales para cualquier ingeniero: matemáticas (aritméticos), comparaciones (relacionales) y decisiones (lógicos).

Operadores aritméticos

Estos son los clásicos. Funcionan casi igual que en tu calculadora científica, pero con una diferencia crítica en la división.

Atención, ingenieros. Este es el error #1 en los exámenes. Si divides dos números enteros (int), C realiza una división entera. Trunca (corta) los decimales, no redondea.

• 10 / 3 es 3 (no 3.333).
• 1 / 2 es 0 (no 0.5).

La Solución: si quieres decimales, al menos UNO de los números debe ser flotante.

• 10.0 / 3 -> 3.3333
• 10 / 3.0 -> 3.3333
• (float)10 / 3 -> 3.3333 (casting explícito).

Operador módulo (%)

El símbolo de porcentaje en C no calcula porcentajes. Calcula el residuo de una división.

• 10 % 3: 10 entre 3 es 3, y sobra 1. El resultado es 1.
• Uso en Ingeniería: es vital para detectar patrones cíclicos (relojes), saber si un número es par (x % 2 == 0) o convertir unidades (segundos a minutos).

Operadores de incremento y asignación

Los programadores somos eficientes (o perezosos). C nos da atajos para escribir menos.

Incremento y decremento (++, —)

Sirven para sumar o restar 1 a una variable.

• contador++ es lo mismo que contador = contador + 1

El matiz sutil (prefijo vs postfijo):

• a = i++: usa el valor de i y luego increméntalo.
• a = ++i: incrementa i y luego usa el nuevo valor.

Asignación compuesta

• a += 5 equivale a a = a + 5
• a *= 2 equivale a a = a * 2

Operadores relacionales

Aquí dejamos las matemáticas y entramos a la lógica. Estos operadores hacen preguntas a la computadora. El resultado de estas operaciones siempre es un valor booleano: 1 (Verdadero) o 0 (Falso).

Error común: = vs ==

Grábate esto a fuego:

• = es Asignación (orden): “variable, toma este valor”.
• == es Comparación (pregunta): “¿variable, tienes este valor?”.

Si escribes if (presion = 0), estás asignando 0 a la presión (y destruyendo el dato original). Debes escribir if (presion == 0).

Operadores lógicos

¿Qué pasa si necesito que se cumplan dos condiciones para activar una alarma? (Ej: temperatura alta y presión baja). Usamos lógica booleana.

1. Operador AND (Y)

• Símbolo: && (doble “ampersand”)
• Lógica: el resultado es Verdadero solo si AMBOS lados son verdaderos. Si uno solo falla, todo es falso. Es muy estricto.
• Analogía eléctrica: un circuito en SERIE. La corriente solo pasa si el interruptor A Y el interruptor B están cerrados.
• Ejemplo: (temperatura > 50) && (presion < 100)

2. Operador OR (O)

• Símbolo: || (doble barra vertical o “pipe”)
• Lógica: El resultado es Verdadero si AL MENOS UNO de los lados es verdadero. Solo da falso si absolutamente todo es falso. Es más permisivo.
• Analogía eléctrica: Un circuito en PARALELO. La luz se prende si activas el interruptor A O si activas el interruptor B (o los dos).
• Ejemplo: (tecla_presionada == ‘S’) || (tecla_presionada == ‘s’) (acepta mayúscula o minúscula).

3. Operador NOT (NO)

• Símbolo: ! (signo de exclamación)
• Lógica:invierte el valor.
  • Si algo es Verdadero, lo convierte en Falso.
  • Si algo es Falso, lo convierte en Verdadero.
• Analogía eléctrica: un INVERSOR. Si hay voltaje en la entrada, la salida se apaga.
• Ejemplo: if (!sistema_encendido) (se lee: “si el sistema NO está encendido…”).

Ejemplo

bool sistema_seguro = (temperatura < 100) && (nivel_aceite > 10);
// Para que sea seguro, la temperatura DEBE ser baja Y el aceite DEBE ser suficiente.

Pruebas

Vamos a Visual Studio. Escribiremos un programa que simule el chequeo de un sistema industrial. Usaremos todos los operadores.

#include <stdio.h>
#include <stdbool.h>

int main() {
    // --- 1. Datos de entrada (Sensores simulados) ---
    int combustible = 100;    // Litros
    int temperatura = 85;     // Grados
    int presion = 200;        // PSI

    // --- 2. Operaciones Aritméticas ---
    // El consumo es 3 litros por hora. Calculamos autonomía entera.
    int horas_autonomia = combustible / 3; 
    
    // Calculamos el residuo exacto de combustible tras esas horas
    int combustible_sobrante = combustible % 3;

    printf("=== REPORTE DE ESTADO ===\n");
    printf("Autonomia estimada: %d horas (Sobran %d litros)\n", horas_autonomia, combustible_sobrante);

    // --- 3. Operaciones Relacionales y Lógicas ---
    
    // REGLA 1: Alarma si temperatura > 90 O presion > 250
    bool alarma_critica = (temperatura > 90) || (presion > 250);

    // REGLA 2: Sistema OK si NO hay alarma Y tenemos combustible
    bool sistema_ok = !alarma_critica && (combustible > 0);

    // REGLA 3: Comparación directa (Cuidado con el ==)
    bool reserva_activa = (combustible == 10); 

    // --- 4. Salida de Diagnóstico (1 = True, 0 = False) ---
    printf("\n--- DIAGNOSTICO ---\n");
    printf("¿Alarma Critica Activada?: %d \n", alarma_critica);
    printf("¿Sistema Operativo?: %d \n", sistema_ok);
    printf("¿Estamos en reserva exacta?: %d \n", reserva_activa);

    // --- 5. Incrementos ---
    printf("\nSimulando una hora de uso...\n");
    combustible -= 3; // Operador compuesto: Gastamos 3 litros
    printf("Combustible actual: %d litros\n", combustible);

    return 0;
}

Datos importantes:

• División: int / int pierde decimales. Usa float si necesitas precisión.
• Módulo (%): tu mejor amigo para ciclos y residuos.
• Comparación: == pregunta, = ordena. No los confundas.
• Lógica: usa paréntesis (a > b) && (c < d) para agrupar condiciones y evitar errores de precedencia.

En los siguientes artículos, le daremos cerebro a nuestro código. Aprenderemos a hacer que el programa tome caminos diferentes automáticamente.

Gracias por leernos.
Si te gusto este artículo, únete a nuestra comunidad en Facebook o WhatsApp para más…
¡Hasta la próxima!