Différence de temps en C++

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 y a aussi maintenant une implémentation boost de <chrono>.

Si vous utilisez win32 FILETIME est le plus précis 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 voulez calculer la différence entre deux fois en millisecondes, faites ce qui 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 );
}

La fonction horloge vous donne une minuterie milliseconde, mais ce n'est pas la plus grande. Sa résolution réelle, va dépendre de votre système. Vous pouvez essayer

#include <time.h>

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

Et voyez comment sont vos résultats.

Vous pouvez utiliser gettimeofday pour obtenir le nombre de microsecondes depuis l'époque. Le segment 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 est 1000 microsecondes.

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

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

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

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

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