Condicionales en C — if, else if, else y switch sin rodeos
Los condicionales en C if else switch son la base de cualquier programa que tome decisiones. Si vienes de Python ya conoces la lógica, la diferencia está en la sintaxis. En C los paréntesis en la condición son obligatorios, las llaves delimitan los bloques y el switch/case tiene un comportamiento que sorprende a todo el mundo la primera vez.
En este artículo vemos todo con ejemplos reales en gedit y Fedora.
Si todavía no tienes el entorno configurado sigue la guía de instalar gedit y gcc.
Tabla de Contenidos
La estructura if/else if/else
La lógica es idéntica a Python — lo que cambia es la sintaxis:
/* En C */
if (condicion) {
/* bloque si es verdad */
} else if (otra_condicion) {
/* bloque alternativo */
} else {
/* bloque por defecto */
}
Comparado con Python:
# En Python
if condicion:
# bloque
elif otra_condicion:
# bloque
else:
# bloque
Las tres diferencias clave:
1. Los paréntesis en la condición son obligatorios en C. En Python if x > 5:, en C if (x > 5).
2. Las llaves {} delimitan el bloque. En Python la indentación es suficiente. En C las llaves son obligatorias cuando el bloque tiene más de una instrucción, con una sola instrucción son opcionales pero es buena práctica ponerlas siempre.
3. elif en Python es else if en C, dos palabras separadas.
#include <stdio.h>
int main() {
float nota;
printf("Introduce tu nota (0-10): ");
scanf("%f", ¬a);
if (nota >= 9.0) {
printf("Sobresaliente\n");
} else if (nota >= 7.0) {
printf("Notable\n");
} else if (nota >= 5.0) {
printf("Aprobado\n");
} else {
printf("Suspenso\n");
}
return 0;
}
Las llaves — cuándo son obligatorias
En C las llaves son obligatorias cuando el bloque tiene más de una instrucción. Con una sola son opcionales:
/* Esto compila y funciona */
if (x > 5)
printf("mayor\n");
/* Pero esto es un error silencioso típico */
if (x > 5)
printf("mayor\n");
printf("que cinco\n"); /* esto siempre se ejecuta — no está en el if */
El segundo printf siempre se ejecuta aunque parezca que está dentro del if. La indentación en C no tiene significado — solo las llaves delimitan bloques.
Regla de oro: pon siempre llaves aunque el bloque tenga una sola instrucción. Evita muchos bugs silenciosos.
/* Siempre así */
if (x > 5) {
printf("mayor\n");
}
Condicionales sin llaves — el error más traicionero
Este es el error más común en IC2 y el más difícil de encontrar porque el código compila sin errores:
int x = 3;
if (x > 5)
printf("A\n");
printf("B\n"); /* siempre se ejecuta */
/* Salida: B */
/* El programador esperaba: nada */
En Python esto sería imposible porque la indentación es parte de la sintaxis. En C la indentación es decorativa — sin llaves solo la siguiente línea pertenece al if.
El operador ternario en C
Para condiciones simples de una línea existe el operador ternario, igual que en Python pero con diferente sintaxis:
/* C */
int resultado = (x > 5) ? 1 : 0;
printf("%s\n", (nota >= 5) ? "Aprobado" : "Suspenso");
/* Python equivalente */
resultado = 1 if x > 5 else 0
Útil para asignaciones simples pero no abuses, si la condición es compleja usa if/else completo.
El switch/case — cuándo usarlo y por qué sorprende
El switch evalúa una expresión entera y salta al case que coincida. Es más eficiente que una cadena larga de if/else if cuando comparas el mismo valor contra muchas opciones:
#include <stdio.h>
int main() {
int opcion;
printf("Elige opción (1-3): ");
scanf("%d", &opcion);
switch (opcion) {
case 1:
printf("Elegiste la opción 1\n");
break;
case 2:
printf("Elegiste la opción 2\n");
break;
case 3:
printf("Elegiste la opción 3\n");
break;
default:
printf("Opción no válida\n");
break;
}
return 0;
}
El default — el caso por defecto
El default es el caso que se ejecuta cuando ningún case coincide con el valor de la expresión. Es opcional pero muy recomendable siempre, sin él, si el usuario introduce un valor inesperado el programa no hace nada y no avisa:
switch (opcion) {
case 1:
printf("Opción 1\n");
break;
case 2:
printf("Opción 2\n");
break;
default:
/* se ejecuta si opcion no es 1 ni 2 */
printf("Opción no válida\n");
break;
}
Equivale al else final de un if/else if/else, es el «en cualquier otro caso». El break en default es técnicamente opcional porque es el último caso, pero ponlo siempre por consistencia.
El break en switch — lo que más sorprende
Aquí está la sorpresa que todo el mundo se lleva la primera vez con switch. Si no pones break al final de un case, la ejecución cae al siguiente case (fall-through):
int x = 1;
switch (x) {
case 1:
printf("caso 1\n");
/* sin break — cae al siguiente */
case 2:
printf("caso 2\n");
break;
case 3:
printf("caso 3\n");
break;
}
Salida:
caso 1 caso 2
Aunque x vale 1, también ejecuta el case 2 porque no hay break. En Python esto no existe, cada elif es independiente. En C el break es obligatorio si no quieres que caiga al siguiente case.
El fall-through a veces se usa intencionalmente cuando varios casos hacen lo mismo:
switch (dia) {
case 1:
case 7:
printf("Fin de semana\n");
break;
case 2:
case 3:
case 4:
case 5:
case 6:
printf("Día laborable\n");
break;
}
Pero en general siempre pon break al final de cada case.
switch vs if/else, cuándo usar cada uno
/* USA switch cuando: */
/* - Comparas la MISMA variable entera contra valores fijos */
/* - Tienes 3 o más casos */
switch (opcion) { ... }
/* USA if/else cuando: */
/* - Las condiciones son rangos (>, <, >=) */
/* - Las condiciones son diferentes variables */
/* - Las condiciones son flotantes */
if (nota >= 9.0) { ... } /* switch no puede con >= */
if (x > 5 && y < 3) { ... } /* switch no puede con && */
if (temperatura > 37.5) { ... } /* switch no acepta float */
Limitaciones del switch en C
- Solo acepta expresiones enteras (
int,char), no aceptafloatnidouble - Solo compara igualdad — no rangos ni condiciones complejas
- Los valores de
casedeben ser constantes — no variables
Visualízalo con Python Tutor
Copia este código en pythontutor.com seleccionando C como lenguaje:
#include <stdio.h>
int main() {
int x = 2;
switch (x) {
case 1:
printf("uno\n");
case 2:
printf("dos\n");
case 3:
printf("tres\n");
break;
default:
printf("otro\n");
}
return 0;
}
Ejecuta paso a paso y observa cómo el fall-through hace que se ejecuten los casos 2 y 3 aunque x vale 2. Luego añade break después del case 2 y observa la diferencia.
Resumen rápido
/* IF/ELSE IF/ELSE */
if (condicion) { /* paréntesis obligatorios */
/* instrucciones */
} else if (otra) {
/* instrucciones */
} else {
/* instrucciones */
}
/* REGLAS */
/* 1. Paréntesis en condición — obligatorios */
/* 2. Llaves — siempre, aunque sea una instrucción */
/* 3. else if — dos palabras (no elif como Python) */
/* 4. Sin llaves — solo la siguiente línea es del if */
/* OPERADOR TERNARIO */
resultado = (condicion) ? valor_si_true : valor_si_false;
/* SWITCH */
switch (expresion_entera) {
case valor1:
/* instrucciones */
break; /* OBLIGATORIO para no caer al siguiente */
case valor2:
/* instrucciones */
break;
default:
/* si ningún case coincide */
break;
}
/* SWITCH — LIMITACIONES */
/* Solo enteros, solo igualdad, solo constantes */
/* Para rangos y flotantes → usa if/else */
/* FALL-THROUGH — sin break cae al siguiente case */
/* Útil para agrupar casos que hacen lo mismo */
En el próximo artículo vemos los bucles en C, for, while y do...while, donde las diferencias con Python son aún más importantes.
Conditionals in C — if, else if, else and switch without complications
Conditionals in C if else switch are the foundation of any program that makes decisions. If you come from Python you know the logic — the difference is in the syntax. Mandatory parentheses, curly braces for blocks, and switch/case behaviour that surprises everyone the first time.
if/else if/else structure
if (condition) {
/* block */
} else if (another_condition) {
/* block */
} else {
/* default block */
}
Three key differences from Python:
1. Parentheses around condition, mandatory in C.
2. Curly braces {} delimit blocks, indentation means nothing.
3. elif in Python is else if in C, two separate words.
#include <stdio.h>
int main() {
float grade;
printf("Enter your grade (0-10): ");
scanf("%f", &grade);
if (grade >= 9.0) {
printf("Outstanding\n");
} else if (grade >= 7.0) {
printf("Good\n");
} else if (grade >= 5.0) {
printf("Passed\n");
} else {
printf("Failed\n");
}
return 0;
}
Curly braces — the most treacherous silent error
/* This compiles but is WRONG */
if (x > 5)
printf("A\n");
printf("B\n"); /* always executes — NOT inside the if */
In Python indentation IS the syntax. In C indentation is decorative, without braces only the next line belongs to the if.
Golden rule: always use curly braces even for single-line blocks.
Ternary operator
/* C */ int result = (x > 5) ? 1 : 0; /* Python equivalent */ result = 1 if x > 5 else 0
switch/case
switch (option) {
case 1:
printf("Option 1\n");
break; /* MANDATORY — without it falls through to next case */
case 2:
printf("Option 2\n");
break;
default:
printf("Invalid\n");
break;
}
The break in switch — what surprises everyone
Without break execution falls through to the next case:
int x = 1;
switch (x) {
case 1:
printf("one\n"); /* no break — falls through */
case 2:
printf("two\n");
break;
}
/* Output: one, two */
Fall-through is sometimes useful to group cases:
switch (day) {
case 1:
case 7:
printf("Weekend\n");
break;
default:
printf("Weekday\n");
break;
}
switch vs if/else
/* USE switch when: */ /* comparing SAME integer variable against fixed values */ /* USE if/else when: */ /* ranges (>, <, >=) */ /* different variables */ /* floats */ /* complex conditions (&&, ||) */
switch limitations: integers only, equality only, constant values only.
Quick summary
/* IF/ELSE */
if (condition) { /* parentheses mandatory */
/* ... */
} else if (other) { /* else if — two words */
/* ... */
} else {
/* ... */
}
/* Always use {} even for single lines */
/* TERNARY */
result = (condition) ? true_value : false_value;
/* SWITCH */
switch (integer_expression) {
case value1:
/* ... */
break; /* mandatory to stop fall-through */
default:
break;
}
/* Only integers, only equality, only constants */
2 comentarios