HOWTO · C++

Ottieni tempo in millisecondi in C++

Questo articolo introduce come ottenere il tempo in millisecondi in C++

In questa pagina

Per ottenere il timestamp attuale dell’orologio di sistema in millisecondi in C++, acquisisci una sola volta std::chrono::system_clock::now() e converti la durata trascorsa dall’epoca di quell’orologio. Usa questo valore come timestamp da confrontare con altri dati basati sull’orologio di sistema. Per misurare la durata di un’operazione, usa invece un orologio monotono come std::chrono::steady_clock: l’orologio di sistema può essere regolato mentre il programma è in esecuzione.

Scegli l’orologio in base a ciò che devi misurare: un timestamp o il tempo trascorso

Un timestamp rappresenta un istante dell’orologio di sistema. Una misura del tempo trascorso è la differenza tra due letture dell’orologio. std::chrono::system_clock è pensato per l’ora di sistema ed è la scelta standard in C++ per ottenere un timestamp attuale. La sua epoca è definita dall’orologio: il codice C++ portabile non dovrebbe quindi presumere che la durata restituita usi sempre l’epoca Unix. Se l’applicazione richiede un timestamp Unix, verifica questa ipotesi sulla piattaforma di destinazione oppure usa un’API che specifichi l’ora Unix.

Per misurare il tempo trascorso, acquisisci entrambe le letture con std::chrono::steady_clock e calcolane la differenza. Questo orologio è progettato per avanzare con regolarità e non rappresenta un timestamp di calendario. Così, un’eventuale regolazione dell’orologio non influenza la misura della durata.

Ottieni un timestamp in millisecondi con std::chrono::system_clock

Chiama now() una sola volta, poi usa time_since_epoch() e duration_cast per esprimere in millisecondi la durata associata a quel punto nel tempo. La conversione di una durata più precisa in millisecondi tronca la parte frazionaria: non arrotonda al millisecondo più vicino. Inoltre, la risoluzione effettiva dell’orologio potrebbe essere inferiore al millisecondo; il fatto che l’intero restituito sia espresso in millisecondi non garantisce quindi una precisione millisecondo.

Per ottenere un timestamp attuale dell’orologio di sistema in millisecondi, acquisisci un unico punto nel tempo e converti la relativa durata:

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

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

Questo programma stampa un timestamp che varia in base all’orologio e al momento dell’esecuzione; non esiste quindi un valore fisso da riportare come output.

Ottieni un timestamp POSIX con gettimeofday

Nei sistemi POSIX, gettimeofday è un’alternativa che restituisce in una struttura timeval i secondi e i microsecondi trascorsi dall’epoca Unix. Includi <sys/time.h> e controlla il valore restituito prima di leggere i campi. Converti i microsecondi in millisecondi dividendo tv_usec per 1.000, quindi somma il risultato ai secondi. Questa API è specifica di POSIX e non è un’interfaccia C++ portabile su tutti i sistemi operativi.

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

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

Il valore stampato varia in base all’orologio. Usa questo approccio quando ti serve specificamente la compatibilità con POSIX; altrimenti, preferisci l’esempio con la libreria standard std::chrono::system_clock.

Perché time() non può offrire precisione al millisecondo

La funzione della libreria C time() restituisce un valore time_t espresso in secondi interi. Moltiplicarlo per 1.000 cambia la scala del numero, ma non permette di recuperare la frazione di secondo. Il risultato è quindi soltanto la rappresentazione, in millisecondi, di un timestamp con precisione al secondo, non una misura precisa al millisecondo.

Il codice e le etichette o gli output visibili in questa sezione restano in inglese.

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

Questo valore cambia nel tempo, ma avanza a intervalli di un secondo. Scegli time() solo se è sufficiente una risoluzione al secondo. Per i normali timestamp in C++, usa std::chrono::system_clock; se serve un’interfaccia specifica di POSIX, usa gettimeofday. Per misurare il tempo trascorso, usa un orologio monotono.