C++ Academy · Aula

Durações e relógios

Meça intervalos de tempo

Durações e relógios é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Por que usar <chrono>

A biblioteca <chrono> oferece ao C++ uma maneira segura quanto aos tipos de trabalhar com o tempo. Em vez de inteiros simples, você usa durações e pontos de tempo fortemente tipados, para que o compilador detecte erros de unidade.

Você não confunde mais segundos e milissegundos.
As unidades fazem parte do 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;
}

O que é uma duração

Uma std::chrono::duration representa um intervalo de tempo. Ela armazena uma contagem de marcações e uma razão que descreve o período de cada marcação. Aliases predefinidos abrangem unidades comuns.

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;
}

Literais de duração

O espaço de nomes std::chrono_literals permite escrever durações com sufixos como 5s ou 200ms, fazendo com que o código se pareça com uma frase comum.

#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;
}

Convertendo durações

duration_cast converte entre unidades. A conversão de uma unidade mais precisa para uma mais ampla faz um truncamento, portanto 1500 ms se tornam 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 com durações

As durações aceitam +, -, * e /. Ao combinar unidades, a conversão é feita automaticamente para a unidade comum mais 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;
}

Durações de ponto flutuante

Você pode usar uma representação de ponto flutuante para preservar valores fracionários durante a conversão, evitando o truncamento das durações inteiras.

#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;
}

O que é um relógio

Um relógio fornece o horário atual. A biblioteca padrão oferece três:

system_clock — horário civil
steady_clock — nunca retrocede, ideal para medições de tempo
high_resolution_clock — menor marcação disponível

#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;
}

Relógio do sistema

system_clock acompanha o horário do calendário do mundo real e pode ser convertido em um time_t para exibição. Ele pode saltar quando o relógio do sistema é ajustado.

#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;
}

Relógio monotônico

steady_clock é monotônico: avança apenas a uma taxa constante. Use-o sempre que medir tempo decorrido, nunca 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;
}

Resolução do relógio

Cada relógio expõe seu period como uma razão determinada em tempo de compilação. Você também pode verificar em tempo de compilação se um relógio é estável.

#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;
}

Reunindo tudo

Combine relógios e durações: leia dois pontos de tempo e calcule a diferença como uma duração na unidade escolhida.

#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;
}

Verificação rápida

Teste sua compreensão sobre qual relógio usar para medir o tempo.

Recapitulação

Você aprendeu que <chrono> fornece:

durações — intervalos de tempo seguros quanto aos tipos, com literais como 5s
duration_cast para converter unidades (trunca inteiros)
relógios — system_clock, steady_clock, high_resolution_clock
use steady_clock para medir intervalos

Em seguida, você representará instantes específicos com pontos de tempo.

Perguntas Frequentes

A aula “Durações e relógios” é grátis?

Sim — o texto completo de “Durações e relógios” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Durações e relógios”?

Meça intervalos de tempo Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Durações e relógios”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy