C++ Academy · Lección

Duraciones y relojes

Mida intervalos de tiempo

Duraciones y relojes es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

¿Por qué <chrono>?

La biblioteca <chrono> proporciona a C++ una forma segura con respecto a los tipos de trabajar con el tiempo. En lugar de enteros sin tipo, se utilizan duraciones y puntos temporales con tipos fuertes, de modo que el compilador detecta los errores de unidades.

Ya no confundirá segundos con milisegundos.
Las unidades forman parte del sistema de tipos.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    seconds s{5};
    std::cout << "Duration: " << s.count() << " seconds\n";
    return 0;
}

¿Qué es una duración?

Un std::chrono::duration representa un intervalo de tiempo. Almacena un número de tics y una proporción que describe el periodo de cada tic. Los alias predefinidos cubren las unidades habituales.

hours, minutes, seconds
milliseconds, microseconds, nanoseconds

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    milliseconds ms{1500};
    std::cout << ms.count() << " ms\n";
    return 0;
}

Literales de duración

El espacio de nombres std::chrono_literals permite escribir duraciones con sufijos como 5s o 200ms, haciendo que el código se lea como lenguaje natural.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono_literals;
    auto wait = 3s;
    auto blink = 250ms;
    std::cout << wait.count() << "s, " << blink.count() << "ms\n";
    return 0;
}

Convertir duraciones

duration_cast convierte entre unidades. Convertir de una unidad más precisa a otra menos precisa trunca el valor, por lo que 1500 ms se convierten en 1 s.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    milliseconds ms{1500};
    seconds s = duration_cast<seconds>(ms);
    std::cout << s.count() << " whole seconds\n";
    return 0;
}

Aritmética con duraciones

Las duraciones admiten +, -, * y /. Al combinar unidades, se convierten automáticamente a la unidad común más precisa.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto total = minutes{2} + seconds{30};
    std::cout << total.count() << " seconds total\n";
    return 0;
}

Duraciones de coma flotante

Puede usar una representación de coma flotante para conservar los valores fraccionarios al convertir, evitando el truncamiento de las duraciones enteras.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    milliseconds ms{1500};
    duration<double> secs = ms;
    std::cout << secs.count() << " seconds\n";
    return 0;
}

¿Qué es un reloj?

Un reloj proporciona la hora actual. La biblioteca estándar ofrece tres:

system_clock — hora del sistema
steady_clock — nunca retrocede, ideal para medir tiempos
high_resolution_clock — el tic más preciso disponible

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto now = steady_clock::now();
    std::cout << "Got a time point: " << (now.time_since_epoch().count() > 0) << '\n';
    return 0;
}

system_clock

system_clock registra la hora real del calendario y se puede convertir a un time_t para mostrarla. Puede saltar si se ajusta el reloj del sistema.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto tp = system_clock::now();
    auto secs = duration_cast<seconds>(tp.time_since_epoch());
    std::cout << "Seconds since epoch is positive: " << (secs.count() > 0) << '\n';
    return 0;
}

steady_clock

steady_clock es monótono: solo avanza a un ritmo constante. Úselo siempre que mida tiempo transcurrido; nunca use system_clock.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto a = steady_clock::now();
    auto b = steady_clock::now();
    std::cout << "Monotonic: " << std::boolalpha << (b >= a) << '\n';
    return 0;
}

Resolución del reloj

Cada reloj expone su period como una proporción determinada en tiempo de compilación. También puede comprobar en tiempo de compilación si un reloj es estable.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    std::cout << "steady_clock is_steady: " << std::boolalpha << steady_clock::is_steady << '\n';
    std::cout << "system_clock is_steady: " << system_clock::is_steady << '\n';
    return 0;
}

Reunir todos los conceptos

Combine relojes y duraciones: lea dos puntos temporales y calcule la diferencia como una duración en la unidad que elija.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto start = steady_clock::now();
    long sum = 0;
    for (int i = 0; i < 1000000; ++i) sum += i;
    auto end = steady_clock::now();
    auto us = duration_cast<microseconds>(end - start);
    std::cout << "Loop took at least 0 us: " << (us.count() >= 0) << '\n';
    return 0;
}

Comprobación rápida

Compruebe su comprensión de qué reloj debe usar para medir el tiempo.

Repaso

Ha aprendido que <chrono> proporciona:

duraciones — intervalos de tiempo seguros con respecto a los tipos, con literales como 5s
duration_cast para convertir unidades (trunca los enteros)
relojes — system_clock, steady_clock, high_resolution_clock
use steady_clock para medir intervalos

A continuación, representará momentos concretos en el tiempo con puntos temporales.

Preguntas frecuentes

¿La lección «Duraciones y relojes» es gratis?

Sí — el texto completo de «Duraciones y relojes» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Duraciones y relojes»?

Mida intervalos de tiempo Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Duraciones y relojes»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy