Clasificación de las Sentencias en C

En el lenguaje C, las instrucciones se dividen en cinco categorías principales: sentencias de expresión, llamadas a funciones, sentencias de control, sentencias compuestas y sentencias vacías. Las sentencias de control son fundamentales para dirigir el flujo de ejecución del prorgama y se clasifican en tres grupos:

• Sentencias de selección (condicionales): if y switch.
• Sentencias de iteración (bucles): while, for y do...while.
• Sentencias de salto: break, continue, goto y return.

Sentencias de Selección

La sentencia if

La estructura if-else permite eejcutar bloques de código basados en el resultado de una expresión booleana. Es importante recordar que la cláusula else siempre se asocia con el if más cercano que no tenga un else asignado.

#include <stdio.h>

int main() {
    float puntuacion = 0.0;
    printf("Ingrese la puntuacion del estudiante: ");
    scanf("%f", &puntuacion);
    
    if (puntuacion >= 70.0) {
        printf("Estado: Aprobado\n");
    } else {
        printf("Estado: Reprobado\n");
    }
    return 0;
}

La sentencia switch

La sentencia switch es ideal para evaluar una expresión entera frente a múltiples valores constantes (etiquetas case). Para evitar que la ejecución continúe hacia los siguientes casos (efecto fall-through), es obligatorio utilizar la sentencia break. Además, se puede incluir una etiqueta default para manejar valores que no coincidan con ningún case.

#include <stdio.h>

int main() {
    char operador = '+';
    int operando_a = 10, operando_b = 5;
    
    switch (operador) {
        case '+':
            printf("Resultado: %d\n", operando_a + operando_b);
            break;
        case '-':
            printf("Resultado: %d\n", operando_a - operando_b);
            break;
        case '*':
            printf("Resultado: %d\n", operando_a * operando_b);
            break;
        case '/':
            if (operando_b != 0) printf("Resultado: %d\n", operando_a / operando_b);
            else printf("Error: Division por cero\n");
            break;
        default:
            printf("Operador no reconocido.\n");
            break;
    }
    return 0;
}

Sentencias de Iteración

Bucle while

El bucle while evalúa una condición antes de ejecutar el bloque de código. Si la condición es falsa desde el inicio, el bloque no se ejecutará ni una sola vez.

#include <stdio.h>

int main() {
    int suma = 0;
    int numero = 1;
    
    while (numero > 0) {
        printf("Ingrese un numero (negativo para terminar): ");
        scanf("%d", &numero);
        if (numero > 0) {
            suma += numero;
        }
    }
    printf("La suma total es: %d\n", suma);
    return 0;
}

Control de bucles:

• break: Termina abruptamente el bucle, transfiriendo el control a la sentencia inmediatamente posterior.
• continue: Omite el resto de las instrucciones en la iteración actual y salta directamente a la evaluación de la condición para la siguiente iteración.

Bucle for

El bucle for consolida la inicialización, la evaluación de la condición y la actualización de la variable de control en una sola línea, lo que mejora la legibilidad y evita errores de alcance en las variables.

#include <stdio.h>

int main() {
    int valores[] = {34, 12, 78, 5, 91, 43};
    int tamano = sizeof(valores) / sizeof(valores[0]);
    int maximo = valores[0];
    
    for (int i = 1; i < tamano; i++) {
        if (valores[i] > maximo) {
            maximo = valores[i];
        }
    }
    printf("El valor maximo en el arreglo es: %d\n", maximo);
    return 0;
}

Nota: Se recomienda no modificar la variable de control dentro del cuerpo del bucle y utilizar intervalos semiabiertos (ej. i < tamano) para facilitar el mantenimiento del código.

Bucle do...while

A diferencia de while, el bucle do...while evalúa la condición al final de la iteración, garantizando que el bloque de código se ejecute al menos una vez. Es ampliamente utilizado para la validación de entradas de usuario.

#include <stdio.h>

int main() {
    int edad = 0;
    do {
        printf("Ingrese una edad valida (mayor a 0): ");
        scanf("%d", &edad);
    } while (edad <= 0);
    
    printf("Edad registrada: %d\n", edad);
    return 0;
}

Implementación de Algoritmos Comunes

A continuación, se presentan ejemplos prácticos que combinan las estructuras de control vistas anteriormente.

Cálculo de Factorial

#include <stdio.h>

int main() {
    int n = 6;
    long factorial = 1;
    
    for (int i = 1; i <= n; ++i) {
        factorial *= i;
    }
    printf("El factorial de %d es %ld\n", n, factorial);
    return 0;
}

Búsqueda Binaria

#include <stdio.h>

int main() {
    int arreglo[] = {2, 8, 15, 23, 37, 45, 59, 68};
    int objetivo = 45;
    int inicio = 0;
    int fin = sizeof(arreglo) / sizeof(arreglo[0]) - 1;
    int encontrado = 0;

    while (inicio <= fin) {
        int medio = inicio + (fin - inicio) / 2;
        if (arreglo[medio] == objetivo) {
            encontrado = 1;
            break;
        }
        if (arreglo[medio] < objetivo)
            inicio = medio + 1;
        else
            fin = medio - 1;
    }
    printf(encontrado ? "Elemento localizado.\n" : "Elemento no encontrado.\n");
    return 0;
}

La sentencia goto

Aunque su uso es generalmente desacosnejado por complicar el flujo lógico del programa, la sentencia goto puede ser útil para salir de estructuras anidadas profundas o para centralizar la limpieza de recursos en el manejo de errores. Es importante destacar que goto no puede saltar entre diferentes funciones.

#include <stdio.h>

int main() {
    int error_critico = 0;
    
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            if (i == 3 && j == 2) {
                error_critico = 1;
                goto manejo_error;
            }
        }
    }
    
manejo_error:
    if (error_critico) {
        printf("Se detecto un error critico. Liberando recursos y finalizando.\n");
    }
    
    return 0;
}