C++ Academy · Aula

Pontos no tempo

Represente momentos no tempo

Pontos no tempo é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 2 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.

O que é um ponto de tempo

Um std::chrono::time_point representa um instante específico medido a partir da época de um relógio. Ele associa um relógio a uma duração desde essa época.

É retornado por clock::now().
Subtrair dois pontos de tempo produz uma duração.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    time_point<steady_clock> tp = steady_clock::now();
    std::cout << "Captured a moment: " << (tp.time_since_epoch().count() != 0) << '\n';
    return 0;
}

time_since_epoch

Todo ponto de tempo pode informar sua distância até a época do relógio com time_since_epoch(), que retorna uma duração.

#include <iostream>
#include <chrono>

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

Subtraindo pontos de tempo

Subtrair um ponto de tempo de outro produz uma duração, o tempo decorrido entre os dois instantes.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto a = steady_clock::now();
    auto b = steady_clock::now();
    auto diff = b - a;
    std::cout << "Elapsed ns is non-negative: " << (diff.count() >= 0) << '\n';
    return 0;
}

Adicionando uma duração

Adicionar uma duração a um ponto de tempo produz um novo ponto de tempo no futuro (ou no passado, ao subtrair). É assim que você calcula prazos.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    using namespace std::chrono_literals;
    auto now = steady_clock::now();
    auto deadline = now + 10s;
    std::cout << "Deadline is after now: " << std::boolalpha << (deadline > now) << '\n';
    return 0;
}

Comparando pontos de tempo

Pontos de tempo do mesmo relógio aceitam todos os operadores de comparação, permitindo verificar se um instante ocorre antes ou depois de outro.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto first = steady_clock::now();
    auto second = steady_clock::now();
    std::cout << std::boolalpha << (first <= second) << '\n';
    return 0;
}

Pontos de tempo específicos do relógio

Um ponto de tempo está vinculado ao tipo do seu relógio. Você não pode comparar diretamente um ponto de tempo de system_clock com um de steady_clock, pois suas épocas são diferentes.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    system_clock::time_point sys = system_clock::now();
    steady_clock::time_point mono = steady_clock::now();
    std::cout << "Both captured: " << ((sys.time_since_epoch().count() != 0) && (mono.time_since_epoch().count() != 0)) << '\n';
    return 0;
}

Convertendo para time_t

system_clock::to_time_t transforma um ponto de tempo do calendário em um time_t no estilo C, que você pode formatar para exibição.

#include <iostream>
#include <chrono>
#include <ctime>

int main() {
    using namespace std::chrono;
    auto tp = system_clock::now();
    std::time_t t = system_clock::to_time_t(tp);
    std::cout << "time_t is positive: " << (t > 0) << '\n';
    return 0;
}

from_time_t

A operação inversa, system_clock::from_time_t, cria um ponto de tempo a partir de um valor time_t, como uma marca temporal armazenada.

#include <iostream>
#include <chrono>
#include <ctime>

int main() {
    using namespace std::chrono;
    std::time_t t = 1000000000;
    auto tp = system_clock::from_time_t(t);
    auto back = system_clock::to_time_t(tp);
    std::cout << "Round trip ok: " << std::boolalpha << (back == t) << '\n';
    return 0;
}

Calculando um prazo

Um padrão comum: capture now(), adicione uma duração de tempo limite e, mais tarde, compare com um novo now() para verificar se o prazo expirou.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    using namespace std::chrono_literals;
    auto deadline = steady_clock::now() + 0ms;
    auto current = steady_clock::now();
    bool expired = current >= deadline;
    std::cout << "Expired: " << std::boolalpha << expired << '\n';
    return 0;
}

Precisão dos pontos de tempo

A precisão de um ponto de tempo corresponde ao tipo de duração do seu relógio. Você pode converter um ponto de tempo para uma unidade mais ampla usando time_point_cast.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto tp = system_clock::now();
    auto secs_tp = time_point_cast<seconds>(tp);
    std::cout << "Cast preserved sign: " << (secs_tp.time_since_epoch().count() > 0) << '\n';
    return 0;
}

Armazenando marcas temporais

Para persistir um instante, converta-o em uma contagem de segundos desde a época, armazene o inteiro e reconstrua o ponto de tempo posteriormente, quando necessário.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto tp = system_clock::now();
    long long stored = duration_cast<seconds>(tp.time_since_epoch()).count();
    std::cout << "Stored value usable: " << (stored > 0) << '\n';
    return 0;
}

Verificação rápida

Teste sua compreensão da aritmética dos pontos de tempo.

Recapitulação

Você aprendeu que um time_point:

marca um instante específico em relação à época de um relógio
informa seu deslocamento por meio de time_since_epoch()
permite adicionar e subtrair durações e fazer comparações
é convertido de e para time_t para exibição e armazenamento

Em seguida, você usará essas ferramentas para avaliar e medir o desempenho do código.

Perguntas Frequentes

A aula “Pontos no tempo” é grátis?

Sim — o texto completo de “Pontos no tempo” é 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 “Pontos no tempo”?

Represente momentos no 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 2 de 4.

Quanto tempo leva a aula “Pontos no tempo”?

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