Midiendo tiempo de ejecución en C con time.h

Aprende a usar con seguridad time.h en C: desde entender el epoch time hasta medir la duración de un bloque de código con difftime. Verás cómo funciona time_t, cómo obtener el tiempo actual con time(NULL) y cómo convertir segundos a horas con printf. Además, comprobarás por qué un ciclo for puede ocupar un núcleo de tu CPU si exageras el conteo.

¿Qué es epoch time y cómo lo usa time.h?

El epoch time es una referencia arbitraria: la cantidad de segundos transcurridos desde el 1 de enero de 1970 a las 00:00. En programación permite un estándar para fecha y hora. En C lo manejamos con time.h y su tipo time_t.

• time_t es un typedef que representa segundos desde epoch.
• time(NULL) devuelve el tiempo actual en segundos.
• La computadora mide en ciclos y relojes de CPU; luego se traduce a segundos.

¿Qué tipo de dato es time_t?

• Es un typedef de un entero “grande”.
• En práctica se trata como entero con formato de impresión de entero largo.
• Permite almacenar muchos segundos desde 1970.

¿Qué hace time(NULL)?

• Entrega el “snapshot” del tiempo actual.
• Sirve para guardar el instante de inicio o fin de una operación.
• Devuelve epoch en segundos.

¿Por qué importa la conversión a horas?

• Para lectura humana, dividir por 3600 convierte segundos a horas.
• Se puede imprimir con formato de entero largo.
• Útil para validar contra cálculos externos si lo deseas.

¿Cómo imprimir horas desde epoch con C y time.h?

Primero incluye las bibliotecas y obtén el tiempo actual. Luego, convierte a horas y muestra el resultado con printf.

#include <stdio.h>
#include <time.h>

int main(void) {
    time_t seconds; // segundos desde epoch
    seconds = time(NULL); // tiempo actual

    printf("Horas desde epoch (1-1-1970 00:00): %ld\n", (long)(seconds / 3600));
    return 0;
}

• Incluye stdio.h para entrada/salida.
• Incluye time.h para time_t y time.
• Usa %ld para imprimir valores largos.
• Divide por 3600 para obtener horas.

¿Qué validar del resultado?

• Debe ser un número grande de horas.
• Cambia al ejecutar en momentos distintos.
• La verificación manual es opcional y solo ilustrativa.

¿Qué buenas prácticas seguir?

• Declara variables con nombres claros: seconds.
• Asegura return 0 al final del main.
• Compila y ejecuta con pasos simples en tu editor o terminal.

¿Cómo medir la duración de un bloque con difftime?

Para saber cuánto tarda una operación, toma dos snapshots con time(NULL) y calcula la diferencia con difftime.

#include <stdio.h>
#include <time.h>

int main(void) {
    time_t begin, end;

    begin = time(NULL); // inicio

    // consumidor de tiempo: ciclo grande
    unsigned long long count = 600000000ULL; // ajusta según tu equipo
    for (unsigned long long i = 0; i < count; ++i) {
        // trabajo vacío a propósito
    }

    end = time(NULL); // fin

    // difftime devuelve double en segundos
    printf("Segundos que duró el for: %.0f\n", difftime(end, begin));
    return 0;
}

• Usa begin y end para marcar inicio y fin.
• difftime(end, begin) devuelve segundos como double.
• Ajusta count para observar 1–4 segundos aproximados.

¿Cómo elegir el tamaño del for?

• Si es demasiado grande: puede tardar minutos.
• Si es muy pequeño: el resultado puede ser 0 segundos.
• Busca un punto medio que muestre segundos sin saturar recursos.

¿Qué observar en el uso de CPU?

• Un for enorme puede ocupar un núcleo completo.
• Verás consumo alto en el administrador de tareas.
• No tiene sentido práctico más allá de medir tiempo; úsalo con criterio.

¿Qué otras funciones de time.h te parecen útiles? Comparte tus ideas y sube un screenshot de tu programa mostrando fecha, hora y día. Me encantará leer tus comentarios.