C++ Tenere traccia di quanti secondi sono passati dall'avvio del programma

Question

Sto scrivendo un programma che verrà utilizzato su una macchina Solaris. Ho bisogno di un modo per tenere traccia di quanti secondi sono trascorsi dall'inizio del programma. Sto parlando molto semplice qui. Ad esempio, avrei un secondo int = 0; ma come andrei sull'aggiornamento della variabile secondi ogni secondo passa?

Sembra che alcune delle varie funzioni del tempo che ho visto funzionino solo su macchine Windows, quindi non sono sicuro.

Qualsiasi suggerimento sarebbe apprezzato.

Grazie per il vostro tempo.

Answer 1

È sufficiente memorizzare la data/l'ora all'avvio dell'applicazione. Ogni volta che è necessario visualizzare per quanto tempo il programma è in esecuzione, ottenere la data/ora corrente e sottrarre il momento dell'avvio dell'applicazione.

Answer 2

Un metodo molto semplice:

#include <time.h> 
time_t start = time(0); 

double seconds_since_start = difftime(time(0), start); 

Lo svantaggio principale di questo è che si deve interrogare per gli aggiornamenti. Avrai bisogno del supporto della piattaforma o di qualche altro lib/framework per farlo in base ad un evento.

Answer 3

Ti stai avvicinando all'indietro. Invece di avere una variabile devi preoccuparti di aggiornare ogni secondo, basta inizializzare una variabile all'avvio del programma con l'ora corrente, e quindi ogni volta che hai bisogno di sapere quanti secondi sono trascorsi, sottrai l'ora corrente da quel momento iniziale. Molto meno overhead in questo modo, e non c'è bisogno di curare un aggiornamento variabile relativo alla temporizzazione.

Answer 4

#include <stdio.h> 
#include <time.h> 
#include <windows.h> 
using namespace std; 
void wait (int seconds); 
int main() 
{ 
    time_t start, end; 
    double diff; 
    time (&start); //useful call 
    for (int i=0;i<10;i++) //this loop is useless, just to pass some time. 
    { 
    printf ("%s\n", ctime(&start)); 
    wait(1); 
    } 
    time (&end);//useful call 

    diff = difftime(end,start);//this will give you time spent between those two calls. 
    printf("difference in seconds=%f",diff); //convert secs as u like 
    system("pause"); 
    return 0; 
} 
void wait (int seconds) 
{ 
    clock_t endwait; 
    endwait = clock() + seconds * CLOCKS_PER_SEC ; 
    while (clock() < endwait) {} 
} 

questo dovrebbe funzionare bene su Solaris/Unix anche, è sufficiente rimuovere arbitri vittoria

Answer 5

Usa std::chrono.

#include <chrono> 
#include <iostream> 

int main(int argc, char *argv[]) 
{ 
    auto start_time = std::chrono::high_resolution_clock::now(); 
    auto current_time = std::chrono::high_resolution_clock::now(); 

    std::cout << "Program has been running for " << std::chrono::duration_cast<std::chrono::seconds>(current_time - start_time).count() << " seconds" << std::endl; 

    return 0; 
} 

Se avete solo bisogno di una risoluzione di secondi, poi std::steady_clock dovrebbe essere sufficiente.