Hacer un temporizador de cuenta regresiva en C++

Un temporizador en C++ puede mostrar una cuenta regresiva o contar hacia arriba, haciendo una pausa entre valores. Para gestionar el tiempo transcurrido de forma portable, usa las funciones chrono y thread de la biblioteca estándar. El ejemplo siguiente recibe una duración total en segundos; no solicita valores separados para minutos y segundos.

Crear un temporizador de cuenta regresiva portable en C++

std::chrono::steady_clock es un reloj monotónico, por lo que resulta adecuado para medir el tiempo transcurrido incluso si se ajusta el reloj del sistema. std::chrono::seconds representa la duración que se pasa a std::this_thread::sleep_for, que solicita pausar el hilo actual. La duración de la pausa es una petición al sistema operativo, no una garantía de que la siguiente instrucción se ejecute en un instante exacto.

Ejecuta este ejemplo:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

#include <chrono>
#include <iostream>
#include <thread>

int main() {
    constexpr int total_seconds = 3;

    for (int remaining = total_seconds; remaining >= 0; --remaining) {
        std::cout << remaining << '\n';
        if (remaining > 0) {
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
    }
}

El bucle comienza con el total configurado, muestra cada valor y resta uno hasta mostrar cero. La condición remaining > 0 evita una pausa innecesaria después del último valor. Cambia total_seconds para ajustar la duración del temporizador. Si la duración procede de una entrada, lee un entero que represente el total de segundos y valida ese valor antes de iniciar el bucle.

Usar funciones de pausa específicas de cada plataforma

Algunos ejemplos antiguos pueden usar API de pausa del sistema operativo. En sistemas Unix o POSIX, usleep recibe microsegundos, y POSIX exige que su argumento sea inferior a 1.000.000; por ejemplo, usleep(500000) solicita una pausa de medio segundo. En Windows, Sleep es una API de Windows que recibe milisegundos, así que Sleep(1000) solicita una pausa de un segundo. La función Sleep no se llama sleep(). Estas funciones son específicas de cada plataforma; std::this_thread::sleep_for de C++ estándar es la opción portable. Consulta la descripción general de windows.h y la guía para obtener el tiempo en milisegundos para ver detalles relacionados.

Crear un temporizador ascendente en C++

Un contador ascendente comienza en un valor elegido y se incrementa hasta alcanzar un límite. Este ejemplo muestra seis valores, del 5 al 10, con una pausa entre ellos. El inicio y el límite son independientes, así que puedes ajustar cualquiera de los dos según la tarea.

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

#include <chrono>
#include <iostream>
#include <thread>

int main() {
    constexpr int start = 5;
    constexpr int limit = 10;

    for (int value = start; value <= limit; ++value) {
        std::cout << value << '\n';
        if (value < limit) {
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
    }
}

A diferencia de la cuenta regresiva, este bucle incrementa el valor y se detiene después de mostrar el límite, incluido este. Se omite la pausa tras la última salida, por lo que el programa termina sin esperar otro intervalo.

Comprender la precisión y las limitaciones de la medición del tiempo

Una pausa no hace que un temporizador sea preciso por sí sola. El sistema operativo puede reanudar un hilo más tarde de lo solicitado, y el trabajo realizado en cada iteración añade tiempo antes de la siguiente pausa. Si la visualización debe seguir el tiempo transcurrido, compara el valor actual de std::chrono::steady_clock con una hora de inicio y calcula la duración restante o transcurrida; no supongas que contar cada llamada de pausa como exactamente un segundo mantendrá la sincronización durante una ejecución larga. Cuando la precisión sea importante, mantén las actualizaciones de la pantalla separadas del cálculo del tiempo.