Como conseguir tempo em milissegundos em C++

Para obter o timestamp atual do relógio de parede em milissegundos em C++, capture std::chrono::system_clock::now() uma única vez e converta a duração desde a época desse relógio. Use esse valor como timestamp que pode ser comparado com outros registros do relógio de parede. Para medir quanto tempo uma operação leva, use um relógio monotônico, como std::chrono::steady_clock; o relógio do sistema pode ser ajustado enquanto o programa está em execução.

Escolha o relógio conforme precise de um timestamp ou de tempo decorrido

Um timestamp representa um instante no relógio de parede do sistema. Uma medição de tempo decorrido é a diferença entre duas leituras do relógio. std::chrono::system_clock foi projetado para medir o tempo de parede e é a opção padrão de C++ para obter um timestamp atual. Sua época é definida pelo relógio; portanto, código portátil em C++ não deve presumir que sua duração bruta sempre usa a época Unix. Se a aplicação precisar de um timestamp Unix, verifique essa suposição na plataforma de destino ou use uma API que especifique o horário Unix.

Para medir o tempo decorrido, faça as duas leituras com std::chrono::steady_clock e subtraia uma da outra. Esse relógio foi projetado para avançar de forma constante e não representa uma data e hora do calendário. Assim, um ajuste do relógio não interfere na medição da duração.

Obtenha um timestamp em milissegundos com std::chrono::system_clock

Chame now() uma vez e, em seguida, use time_since_epoch() e duration_cast para expressar em milissegundos a duração desse ponto no tempo. Converter uma duração mais precisa para milissegundos descarta a fração restante; o valor não é arredondado para o milissegundo mais próximo. A resolução real do relógio também pode ser mais grosseira que um milissegundo. Portanto, a unidade do número inteiro retornado não garante precisão de milissegundos.

Para obter um timestamp atual do relógio de parede em milissegundos, capture um único ponto no tempo e converta sua duração:

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

#include <chrono>
#include <cstdlib>
#include <iostream>

int main() {
  const auto now = std::chrono::system_clock::now();
  const auto milliseconds =
      std::chrono::duration_cast<std::chrono::milliseconds>(
          now.time_since_epoch()).count();

  std::cout << milliseconds << '\n';
  return EXIT_SUCCESS;
}

Este programa imprime um valor de timestamp que varia conforme o relógio e o momento em que é executado; por isso, não há um número fixo para copiar como resultado.

Obtenha um timestamp POSIX com gettimeofday

Em sistemas POSIX, gettimeofday é uma alternativa que informa os segundos e microssegundos desde a época Unix em uma estrutura timeval. Inclua <sys/time.h> e verifique o valor de retorno antes de ler os campos. Converta microssegundos em milissegundos dividindo tv_usec por 1.000 e, em seguida, some esse valor aos segundos. Essa API é específica do POSIX e não é uma interface portátil de C++ para todos os sistemas operacionais.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

#include <cstdlib>
#include <iostream>
#include <sys/time.h>

int main() {
  timeval now{};
  if (gettimeofday(&now, nullptr) != 0) {
    std::cout << "gettimeofday failed\n";
    return EXIT_FAILURE;
  }

  const long long milliseconds =
      static_cast<long long>(now.tv_sec) * 1000 + now.tv_usec / 1000;
  std::cout << milliseconds << '\n';
  return EXIT_SUCCESS;
}

O valor impresso varia conforme o relógio. Use esta abordagem quando precisar especificamente de compatibilidade com POSIX; caso contrário, prefira o exemplo da biblioteca padrão com std::chrono::system_clock.

Entenda por que time() não oferece precisão de milissegundos

A função time() da biblioteca C retorna um valor time_t em segundos inteiros. Multiplicá-lo por 1.000 altera a escala do número, mas não recupera a fração de segundo. Portanto, o resultado é apenas a representação de um timestamp em segundos inteiros com escala de milissegundos, e não uma medição com precisão de milissegundos.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

#include <ctime>
#include <cstdlib>
#include <iostream>

int main() {
  const std::time_t seconds = std::time(nullptr);
  const long long milliseconds = static_cast<long long>(seconds) * 1000;
  std::cout << milliseconds << '\n';
  return EXIT_SUCCESS;
}

Esse valor muda com o tempo, mas avança em intervalos de um segundo. Escolha time() somente quando a resolução em segundos for suficiente. Para código comum de timestamp em C++, use std::chrono::system_clock; use gettimeofday quando precisar de uma interface específica do POSIX e um relógio monotônico para medir o tempo decorrido.