web-dev-qa-db-fra.com

Décalage horaire en C ++

Quelqu'un sait-il comment calculer la différence de temps en C++ en millisecondes? J'ai utilisé difftime mais il n'a pas assez de précision pour ce que j'essaie de mesurer.

c++time
31
Alejo

Vous devez utiliser l'une des structures temporelles les plus spécifiques, soit temporelle (résolution en microsecondes) ou temporelle (résolution en nanosecondes), mais vous pouvez le faire manuellement assez facilement:

#include <time.h>

int diff_ms(timeval t1, timeval t2)
{
    return (((t1.tv_sec - t2.tv_sec) * 1000000) + 
            (t1.tv_usec - t2.tv_usec))/1000;
}

Cela a évidemment des problèmes avec le débordement d'entier si la différence de temps est vraiment grande (ou si vous avez des entiers 16 bits), mais ce n'est probablement pas un cas courant.

19
Tyler McHenry

Je sais que c'est une vieille question, mais il y a une réponse mise à jour pour C++ 0x. Il y a un nouvel en-tête appelé <chrono> qui contient des utilitaires modernes. Exemple d'utilisation:

#include <iostream>
#include <thread>
#include <chrono>

int main()
{
    typedef std::chrono::high_resolution_clock Clock;
    typedef std::chrono::milliseconds milliseconds;
    Clock::time_point t0 = Clock::now();
    std::this_thread::sleep_for(milliseconds(50));
    Clock::time_point t1 = Clock::now();
    milliseconds ms = std::chrono::duration_cast<milliseconds>(t1 - t0);
    std::cout << ms.count() << "ms\n";
}

50ms

Plus d'informations peuvent être trouvées ici:

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2661.htm

Il existe également désormais une mise en œuvre renforcée de <chrono>.

73
Howard Hinnant

si vous utilisez win32 FILETIME est la plus précise que vous pouvez obtenir: Contient une valeur de 64 bits représentant le nombre d'intervalles de 100 nanosecondes depuis le 1er janvier 1601 (UTC).

Donc, si vous souhaitez calculer la différence entre deux fois en millisecondes, procédez comme suit:

UINT64 getTime()
{
    SYSTEMTIME st;
    GetSystemTime(&st);

    FILETIME ft;
    SystemTimeToFileTime(&st, &ft);  // converts to file time format
    ULARGE_INTEGER ui;
    ui.LowPart=ft.dwLowDateTime;
    ui.HighPart=ft.dwHighDateTime;

    return ui.QuadPart;
}

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
    //! Start counting time
    UINT64   start, finish;

    start=getTime();

    //do something...

    //! Stop counting elapsed time
    finish = getTime();

    //now you can calculate the difference any way that you want
    //in seconds:
    _tprintf(_T("Time elapsed executing this code: %.03f seconds."), (((float)(finish-start))/((float)10000))/1000 );
    //or in miliseconds
    _tprintf(_T("Time elapsed executing this code: %I64d seconds."), (finish-start)/10000 );
}
7
Nuno

La fonction d'horloge vous donne une minuterie en millisecondes, mais ce n'est pas le meilleur. Sa résolution réelle dépendra de votre système. Tu peux essayer

#include <time.h>

int clo = clock();
//do stuff
cout << (clock() - clo) << endl;

et voyez comment sont vos résultats.

5
Bill the Lizard

Vous pouvez utiliser gettimeofday pour obtenir le nombre de microsecondes depuis Epoch. Le segment en secondes de la valeur renvoyée par gettimeofday () est le même que celui renvoyé par time () et peut être converti en time_t et utilisé dans difftime. Une milliseconde correspond à 1000 microsecondes.

Après avoir utilisé difftime, calculez vous-même la différence dans le champ de microsecondes.

2
SoapBox

Vous pouvez obtenir une précision micro et nanoseconde hors de Boost.Date_Time .

2
Ferruccio

Si vous cherchez à faire de l'analyse comparative, vous voudrez peut-être voir certains des autrethreads ici sur SO qui discutent du sujet.

Assurez-vous également de bien comprendre la différence entre exactitude et précision.

1
Alastair

Je pense que vous devrez utiliser quelque chose de spécifique à la plate-forme. J'espère que cela n'aura pas d'importance? par exemple. Sous Windows, regardez QueryPerformanceCounter() qui vous donnera bien mieux que des millisecondes.

0
Peter