Capítulo 2: Operadores

Los operadores son los símbolos que te permiten manipular datos: sumar números, comparar valores, combinar condiciones lógicas. En C++ hay muchos tipos de operadores, y entender cómo funcionan es esencial para escribir código efectivo.

Objetivos

• Dominar los operadores aritméticos y sus particularidades
• Entender la diferencia entre pre-incremento y post-incremento
• Usar operadores de comparación y lógicos correctamente
• Conocer operadores bit a bit para manipulación de bajo nivel
• Comprender la precedencia de operadores

Operadores aritméticos

Los operadores aritméticos básicos funcionan como esperarías en matemáticas:

int a = 10;
int b = 3;

int suma = a + b;            // 13
int resta = a - b;           // 7
int multiplicacion = a * b;  // 30
int division = a / b;        // 3 (división entera)
int modulo = a % b;          // 1 (residuo)

std::cout << "División: " << division << std::endl;  // 3
std::cout << "Módulo: " << modulo << std::endl;      // 1

División entera vs división de punto flotante

Un detalle muy importante: cuando divides dos enteros en C++, el resultado es un división entera División que descarta la parte decimal del resultado. El resultado se trunca hacia cero.

Ejemplo: 10 / 3 = 3 (no 3.333...) , no un número decimal.

// División entera trunca hacia 0
int resultado1 = 10 / 3;   // 3 (no 3.333...)
int resultado2 = -10 / 3;  // -3 (no -3.333...)

// Para obtener resultado decimal, usa float o double
double resultado3 = 10.0 / 3.0;  // 3.333333...
double resultado4 = 10 / 3.0;    // 3.333333... (uno es double)

El operador módulo (%)

El operador % (módulo) te da el residuo de una división entera. Es extremadamente útil para:

• Verificar si un número es par o impar: x % 2 == 0
• Ciclar valores dentro de un rango: indice % tamaño
• Extraer dígitos de un número

Operadores de incremento y decremento

Los operadores ++ y -- incrementan o decrementan una variable en 1. La diferencia entre pre-incremento El operador ++x incrementa la variable antes de usar su valor.

Ejemplo: Si x = 5, entonces y = ++x hace que x = 6 y y = 6. (++x) y post-incremento El operador x++ usa el valor de la variable antes de incrementarla.

Ejemplo: Si x = 5, entonces y = x++ hace que y = 5 y luego x = 6. (x++) es crucial:

int x = 5;

// Pre-incremento: incrementa ANTES de usar el valor
int a = ++x;  // x = 6, a = 6

// Post-incremento: usa el valor ANTES de incrementar
int y = 5;
int b = y++;  // b = 5, y = 6

// Lo mismo aplica para decremento
int z = 10;
int c = --z;  // z = 9, c = 9
int d = z--;  // d = 9, z = 8

Operadores de comparación

Los operadores de comparación devuelven un valor bool: true o false:

int a = 10;
int b = 20;

bool igual = (a == b);       // false
bool diferente = (a != b);   // true
bool menor = (a < b);        // true
bool mayor = (a > b);        // false
bool menorIgual = (a <= b);  // true
bool mayorIgual = (a >= b);  // false

// Útil en condicionales
if (a < b) {
    std::cout << "a es menor que b" << std::endl;
}

Operadores lógicos

Los operadores lógicos te permiten combinar expresiones booleanas:

bool a = true;
bool b = false;

bool and_result = a && b;  // false (AND: ambos deben ser true)
bool or_result = a || b;   // true (OR: al menos uno debe ser true)
bool not_result = !a;      // false (NOT: invierte el valor)

// Cortocircuito: && y || no evalúan el segundo operando si no es necesario
int x = 5;
if (x > 0 && x < 10) {  // Si x > 0 es false, no evalúa x < 10
    std::cout << "x está entre 0 y 10" << std::endl;
}

Evaluación en cortocircuito

Los operadores && y || usan evaluación en cortocircuito El segundo operando de && o || no se evalúa si el resultado ya está determinado por el primero.

&&: Si el primero es false, no evalúa el segundo.
||: Si el primero es true, no evalúa el segundo. :

• false && cualquier_cosa → no evalúa cualquier_cosa porque ya es false
• true || cualquier_cosa → no evalúa cualquier_cosa porque ya es true

Esto es útil para evitar errores:

if (ptr != nullptr && ptr->value > 0) {
    // Seguro: solo evalúa ptr->value si ptr no es null
}

Operadores de asignación compuesta

Son atajos para operaciones comunes:

int x = 10;

x += 5;  // x = x + 5;  → x = 15
x -= 3;  // x = x - 3;  → x = 12
x *= 2;  // x = x * 2;  → x = 24
x /= 4;  // x = x / 4;  → x = 6
x %= 4;  // x = x % 4;  → x = 2

// También existen para operadores bit a bit
int y = 8;
y &= 3;  // y = y & 3;
y |= 2;  // y = y | 2;
y ^= 1;  // y = y ^ 1;

Operadores bit a bit

Operan directamente sobre los bits individuales de los números. Son esenciales para programación de bajo nivel, flags, máscaras de bits, y optimizaciones:

int a = 12;  // 1100 en binario
int b = 10;  // 1010 en binario

int and_bit = a & b;  // 1000 = 8 (AND bit a bit)
int or_bit = a | b;   // 1110 = 14 (OR bit a bit)
int xor_bit = a ^ b;  // 0110 = 6 (XOR bit a bit)
int not_bit = ~a;     // Invierte todos los bits

// Desplazamiento de bits
int left = a << 2;   // 110000 = 48 (multiplica por 4)
int right = a >> 1;  // 110 = 6 (divide por 2)

std::cout << "12 << 2 = " << left << std::endl;  // 48

Operador ternario

El operador ternario ? : es un if-else compacto para asignaciones:

int a = 10;
int b = 20;

// Operador ternario: condicion ? valor_si_true : valor_si_false
int max = (a > b) ? a : b;  // max = 20

// Equivalente a:
int max2;
if (a > b) {
    max2 = a;
} else {
    max2 = b;
}

// Útil para asignaciones condicionales simples
std::string mensaje = (edad >= 18) ? "Adulto" : "Menor";

Precedencia de operadores

Al igual que en matemáticas, los operadores tienen un orden de evaluación:

// Sin paréntesis: sigue precedencia de operadores
int resultado1 = 2 + 3 * 4;   // 14 (no 20, porque * tiene mayor precedencia)
int resultado2 = 10 - 4 / 2;  // 8 (no 3)

// Con paréntesis: controlas el orden
int resultado3 = (2 + 3) * 4;   // 20
int resultado4 = (10 - 4) / 2;  // 3

// Múltiples niveles
int resultado5 = ((5 + 3) * 2 - 4) / 2;  // 6

Orden de precedencia (de mayor a menor):

1. Paréntesis ()
2. Incremento/decremento ++ --, negación !
3. Multiplicación, división, módulo * / %
4. Suma, resta + -
5. Desplazamiento << >>
6. Comparación < <= > >=
7. Igualdad == !=
8. AND bit a bit &
9. XOR bit a bit ^
10. OR bit a bit |
11. AND lógico &&
12. OR lógico ||
13. Ternario ? :
14. Asignación = += -= etc.

Resumen

• División entera trunca: 10 / 3 = 3
• ++x incrementa antes, x++ incrementa después
• = asigna, == compara
• && y || usan evaluación en cortocircuito
• Operadores bit a bit manipulan bits individuales
• Usa paréntesis cuando tengas duda sobre precedencia