Operadores

## Objetivos de Aprendizaje - Dominar los operadores aritméticos - Comprender los operadores de comparación - Aprender los operadores lógicos - Trabajar con operadores bit a bit ## Operadores Aritméticos ### Operaciones Básicas ```c int a = 10, b = 3; printf("%d\n", a + b); // 13 (suma) printf("%d\n", a - b); // 7 (resta) printf("%d\n", a * b); // 30 (multiplicación) printf("%d\n", a / b); // 3 (división entera) printf("%d\n", a % b); // 1 (módulo/resto) ``` ### Comportamiento de la División ```c // La división entera trunca printf("%d\n", 10 / 3); // 3, no 3.333 // Para punto flotante printf("%f\n", 10.0 / 3.0); // 3.333... ``` ### Incremento/Decremento ```c int x = 5; // Pre-incremento/decremento printf("%d\n", ++x); // 6 (incrementa primero) printf("%d\n", --x); // 5 (decrementa primero) // Post-incremento/decremento printf("%d\n", x++); // 5 (usa valor, luego incrementa) printf("%d\n", x); // 6 (ahora incrementado) int y = 5; printf("%d\n", y--); // 5 (usa valor, luego decrementa) printf("%d\n", y); // 4 ``` ## Operadores de Comparación ### Operadores Relacionales ```c int a = 5, b = 10; printf("%d\n", a == b); // 0 (falso) printf("%d\n", a != b); // 1 (verdadero) printf("%d\n", a < b); // 1 (verdadero) printf("%d\n", a > b); // 0 (falso) printf("%d\n", a <= b); // 1 (verdadero) printf("%d\n", a >= b); // 0 (falso) ``` ### No Confundir ```c // = es asignación // == es comparación int x = 5; // if (x = 10) // ¡WRONG! Esto asigna 10 a x if (x == 5) // ¡CORRECTO! Esto compara ``` ## Operadores Lógicos ### AND, OR, NOT ```c int a = 1, b = 0; // 1 = verdadero, 0 = falso printf("%d\n", a && b); // 0 (AND - ambos deben ser verdaderos) printf("%d\n", a || b); // 1 (OR - uno debe ser verdadero) printf("%d\n", !a); // 0 (NOT - invierte) ``` ### Evaluación de Cortocircuito ```c // && se detiene si el primero es falso if (x != 0 && y / x > 2) { // Seguro - no dividirá por cero } // || se detiene si el primero es verdadero if (ptr == NULL || ptr->value > 0) { // Seguro - no desreferenciará NULL } ``` ### Tabla de Verdad | A | B | A && B | A \|\| B | !A | |---|---|--------|----------|-----| | 1 | 1 | 1 | 1 | 0 | | 1 | 0 | 0 | 1 | 0 | | 0 | 1 | 0 | 1 | 1 | | 0 | 0 | 0 | 0 | 1 | ## Operadores de Asignación ### Asignación Simple ```c int x = 10; ``` ### Asignación Compuesta ```c int x = 10; x += 5; // x = 15 (x = x + 5) x -= 3; // x = 12 (x = x - 3) x *= 2; // x = 24 (x = x * 2) x /= 4; // x = 6 (x = x / 4) x %= 5; // x = 1 (x = x % 5) ``` ### Asignación Compuesta Bit a Bit ```c int flags = 0b1010; // 10 en decimal flags &= 0b0111; // flags = flags & 0b0111 flags |= 0b0001; // flags = flags | 0b0001 flags ^= 0b0100; // flags = flags ^ 0b0100 ``` ## Operadores Bit a Bit ### Operaciones Binarias ```c int a = 5, b = 3; // 101 y 011 en binario printf("%d\n", a & b); // 1 (AND: 101 & 011 = 001) printf("%d\n", a | b); // 7 (OR: 101 | 011 = 111) printf("%d\n", a ^ b); // 6 (XOR: 101 ^ 011 = 110) printf("%d\n", ~a); // -6 (NOT: ~00000101 = 11111010) printf("%d\n", a << 1); // 10 (desplazamiento izquierda: 101 << = 1010) printf("%d\n", a >> 1); // 2 (desplazamiento derecha: 101 >> = 10) ``` ### Usos Comunes ```c // Verificar si un bit está establecido int flags = 0b1010; if (flags & 0b1000) { printf("Bit 3 está establecido\n"); } // Establecer un bit flags = flags | 0b0001; // Cambiar un bit flags = flags ^ 0b0100; // Extraer los 4 bits inferiores int lower = flags & 0xF; ``` ### Desplazamiento Derecho con Signo **Advertencia:** El desplazamiento derecho en números negativos con signo depende de la implementación. ```c // Para números positivos: desplazamiento aritmético (llena con 0) // Para números negativos: a menudo desplazamiento aritmético (llena con 1) int neg = -4; printf("%d\n", neg >> 1); // Puede ser -2 o -1 dependiendo de la implementación ``` ## Operador Coma ```c // Evalúa izquierda, luego derecha, retorna el valor derecho int x = (a = 5, b = 10, a + b); // x = 15 // Común en bucles for for (int i = 0, j = 10; i < 5; i++, j--) { printf("%d %d\n", i, j); } ``` ## Operador Ternario ### Sintaxis ```c // condición ? valorSiVerdadero : valorSiFalso int max = (a > b) ? a : b; int status = (age >= 18) ? 1 : 0; ``` ### Ternario Anidado ```c int grade = (score >= 90) ? 'A' : (score >= 80) ? 'B' : (score >= 70) ? 'C' : (score >= 60) ? 'D' : 'F'; ``` ## Operador sizeof ```c int x; printf("%zu\n", sizeof(int)); // Tamaño del tipo printf("%zu\n", sizeof(x)); // Tamaño de la variable printf("%zu\n", sizeof 10); // Tamaño de la constante int arr[10]; printf("%zu\n", sizeof(arr)); // 40 (10 * 4 bytes) ``` ## Precedencia de Operadores ### De Mayor a Menor | Prioridad | Operadores | |-----------|-------------------| | 1 | `()` | | 2 | `++`, `--`, `!`, `~` | | 3 | `*`, `/`, `%` | | 4 | `+`, `-` | | 5 | `<<`, `>>` | | 6 | `<`, `>`, `<=`, `>=` | | 7 | `==`, `!=` | | 8 | `&` | | 9 | `^` | | 10 | `\|` | | 11 | `&&` | | 12 | `\|\|` | | 13 | `?:` | | 14 | `=`, `+=`, `-=`, etc. | | 15 | `,` | ### Usar Paréntesis ```c // Precedencia clara if ((a > b) && (c < d)) { } // En lugar de confiar en la memoria if (a > b && c < d) { // Igual, pero menos claro } ``` ## Resumen - Aritméticos: `+`, `-`, `*`, `/`, `%` - Incremento/Decremento: `++x`, `x++`, `--x`, `x--` - Comparación: `==`, `!=`, `<`, `>`, `<=`, `>=` - Lógicos: `&&`, `||`, `!` - Asignación: `=`, `+=`, `-=`, etc. - Bit a bit: `&`, `|`, `^`, `~`, `<<`, `>>` - Ternario: `condición ? verdadero : falso` - sizeof: retorna tamaño en bytes - Usar paréntesis para aclarar precedencia