Usa Timer in C++
-
Usa la funzione
clock()
per implementare un timer in C++ -
Usa la funzione
gettimeofday
per implementare un timer in C++
![Usa Timer in C++](/img/Cpp/feature-image---cpp-timer.webp)
Questo articolo illustrerà più metodi su come utilizzare un timer in C++.
Usa la funzione clock()
per implementare un timer in C++
La funzione clock()
è un metodo compatibile con POSIX per recuperare il tempo del processore del programma. La funzione restituisce il valore intero che deve essere diviso per una costante definita da macro chiamata CLOCKS_PER_SEC
per convertirlo in diversi secondi.
Il seguente codice di esempio implementa due funzioni per trovare il valore massimo in un array int
. La funzione max_index
esegue la ricerca in base all’indice degli elementi, mentre max_value
è basata sul valore. L’obiettivo è calcolare quanto tempo impiegano per trovare il valore massimo int
nell’array di elementi 1,000,000
riempito con numeri interi casuali.
Notate che chiamiamo la funzione clock()
due volte - prima della chiamata max_index
e poi dopo la chiamata. Questo schema di misurazione del tempo può essere impiegato generalmente senza alcun riguardo alla funzione specifica che recupera il tempo. In questo caso, potremmo vedere (a seconda del sistema hardware) che max_value
esegue il lavoro leggermente più velocemente della ricerca basata sull’indice. Attenzione però, questi algoritmi di ricerca massimi hanno una complessità O(N)
e non dovrebbero essere impiegati in nessun codebase professionale tranne forse per la sperimentazione.
#include <chrono>
#include <iostream>
using std::cout;
using std::endl;
int max_index(int arr[], int size) {
size_t max = 0;
for (int j = 0; j < size; ++j) {
if (arr[j] > arr[max]) {
max = j;
}
}
return arr[max];
}
int max_value(int arr[], int size) {
int max = arr[0];
for (int j = 0; j < size; ++j) {
if (arr[j] > max) {
max = arr[j];
}
}
return max;
}
constexpr int WIDTH = 1000000;
int main() {
clock_t start, end;
int max;
int *arr = new int[WIDTH];
std::srand(std::time(nullptr));
for (size_t i = 0; i < WIDTH; i++) {
arr[i] = std::rand();
}
start = clock();
max = max_index(arr, WIDTH);
end = clock();
printf("max_index: %0.8f sec, max = %d\n",
((float)end - start) / CLOCKS_PER_SEC, max);
start = clock();
max = max_value(arr, WIDTH);
end = clock();
printf("max_value: %0.8f sec, max = %d\n",
((float)end - start) / CLOCKS_PER_SEC, max);
exit(EXIT_SUCCESS);
}
Produzione:
max_value: 0.00131400 sec, max = 2147480499
max_value: 0.00089800 sec, max = 2147480499
Usa la funzione gettimeofday
per implementare un timer in C++
gettimeofday
è una funzione di recupero del tempo estremamente accurata nei sistemi basati su Linux, che può essere chiamata anche dal codice sorgente C++. La funzione è stata progettata per ottenere i dati relativi all’ora e al fuso orario, ma quest’ultimo è stato deprezzato per un po’ di tempo e il secondo argomento dovrebbe essere nullptr
invece del fuso orario valido struct
. gettimeofday
memorizza i dati di temporizzazione nella speciale struct
chiamata timeval
, che contiene due membri di dati tv_sec
che rappresentano i secondi e tv_usec
per i microsecondi.
Come regola generale, dichiariamo e inizializziamo le due strutture timeval
prima di chiamare la funzione gettimeofday
. Una volta chiamata la funzione, i dati dovrebbero essere memorizzati con successo nella corrispondente struct
se il valore di ritorno di gettimeofday
è 0
. Altrimenti, l’errore viene indicato restituendo il valore -1
. Si noti che, dopo che le strutture sono state riempite con i dati, è necessario convertirla nel valore unitario comune del tempo. Questo codice di esempio implementa la funzione time_diff
che restituisce il tempo in secondi, che può essere inviato alla console secondo necessità.
#include <sys/time.h>
#include <ctime>
#include <iostream>
using std::cout;
using std::endl;
int max_index(int arr[], int size) {
size_t max = 0;
for (int j = 0; j < size; ++j) {
if (arr[j] > arr[max]) {
max = j;
}
}
return arr[max];
}
int max_value(int arr[], int size) {
int max = arr[0];
for (int j = 0; j < size; ++j) {
if (arr[j] > max) {
max = arr[j];
}
}
return max;
}
float time_diff(struct timeval *start, struct timeval *end) {
return (end->tv_sec - start->tv_sec) + 1e-6 * (end->tv_usec - start->tv_usec);
}
constexpr int WIDTH = 1000000;
int main() {
struct timeval start {};
struct timeval end {};
int max;
int *arr = new int[WIDTH];
std::srand(std::time(nullptr));
for (size_t i = 0; i < WIDTH; i++) {
arr[i] = std::rand();
}
gettimeofday(&start, nullptr);
max = max_index(arr, WIDTH);
gettimeofday(&end, nullptr);
printf("max_index: %0.8f sec, max = %d\n", time_diff(&start, &end), max);
gettimeofday(&start, nullptr);
max = max_value(arr, WIDTH);
gettimeofday(&end, nullptr);
printf("max_value: %0.8f sec, max = %d\n", time_diff(&start, &end), max);
exit(EXIT_SUCCESS);
}
Produzione:
max_value: 0.00126000 sec, max = 2147474877
max_value: 0.00093900 sec, max = 2147474877
Founder of DelftStack.com. Jinku has worked in the robotics and automotive industries for over 8 years. He sharpened his coding skills when he needed to do the automatic testing, data collection from remote servers and report creation from the endurance test. He is from an electrical/electronics engineering background but has expanded his interest to embedded electronics, embedded programming and front-/back-end programming.
LinkedIn Facebook