Comment calculer une différence de temps en C++

Question

Quelle est la meilleure façon de calculer la différence de temps en C++? Je suis à la synchronisation de la vitesse d'exécution d'un programme, donc, je suis intéressé en millisecondes. Mieux encore, secondes.millisecondes..

La accepté de répondre à des œuvres, mais doit inclure ctime ou de temps.h comme indiqué dans les commentaires.

Une autre réponse (dupe) peut être trouvés ici

Answer 1

Voir std::clock() fonction.

const clock_t begin_time = clock();
// do something
std::cout << float( clock () - begin_time ) /  CLOCKS_PER_SEC;

Si vous voulez calculer le temps d'exécution pour l'auto ( pas pour l'utilisateur ), il est préférable de le faire en tops d'horloge ( pas de secondes ).

EDIT:
responsable des fichiers d'en-tête - <ctime> ou <time.h>

Answer 2

si vous êtes à l'aide de c++11, voici un simple wrapper (voir ce gist):

#include <iostream>
#include <chrono>

class Timer
{
public:
    Timer() : beg_(clock_::now()) {}
    void reset() { beg_ = clock_::now(); }
    double elapsed() const { 
        return std::chrono::duration_cast<second_>
            (clock_::now() - beg_).count(); }

private:
    typedef std::chrono::high_resolution_clock clock_;
    typedef std::chrono::duration<double, std::ratio<1> > second_;
    std::chrono::time_point<clock_> beg_;
};

Ou pour le c++03 sur *nix:

#include <iostream>
#include <ctime>

class Timer
{
public:
    Timer() { clock_gettime(CLOCK_REALTIME, &beg_); }

    double elapsed() {
        clock_gettime(CLOCK_REALTIME, &end_);
        return end_.tv_sec - beg_.tv_sec +
            (end_.tv_nsec - beg_.tv_nsec) / 1000000000.;
    }

    void reset() { clock_gettime(CLOCK_REALTIME, &beg_); }

private:
    timespec beg_, end_;
};

Exemple d'utilisation:

int main()
{
    Timer tmr;
    double t = tmr.elapsed();
    std::cout << t << std::endl;

    tmr.reset();
    t = tmr.elapsed();
    std::cout << t << std::endl;
    return 0;
}

Answer 3

Je voudrais sérieusement envisager l'utilisation de Boost, en particulier boost::posix_time::ptime et boost::posix_time::time_duration (à http://www.boost.org/doc/libs/1_38_0/doc/html/date_time/posix_time.html).

Il est multi-plateforme, facile à utiliser, et dans mon expérience, offre le plus haut niveau de temps de résolution d'un système d'exploitation. Éventuellement aussi très important; il offre quelques très belles IO opérateurs.

À utiliser pour calculer la différence de l'exécution du programme (en microsecondes; sans doute exagéré), il ressemblerait à quelque chose comme ceci [navigateur écrite, non testée):

ptime time_start(microsec_clock::local_time());
//... execution goes here ...
ptime time_end(microsec_clock::local_time());
time_duration duration(time_end - time_start);
cout << duration << '\n';

Answer 4

boost 1.46.0 et comprend le Chrono de la bibliothèque:

thread_clock classe permet d'accéder à la véritable fil conducteur l'horloge de mur, c'est à dire le réel du PROCESSEUR de l'horloge temps du thread appelant. Le fil relative heure actuelle peut être obtenu en appelant thread_clock::now()

#include <boost/chrono/thread_clock.hpp>
{
...
    using namespace boost::chrono;
    thread_clock::time_point start = thread_clock::now();
    ...
    thread_clock::time_point stop = thread_clock::now();  
    std::cout << "duration: " << duration_cast<milliseconds>(stop - start).count() << " ms\n";

Answer 5

Dans Windows: utilisez GetTickCount

//GetTickCount defintition
#include <windows.h>
int main()
{

    DWORD dw1 = GetTickCount();

    //Do something 

    DWORD dw2 = GetTickCount();

    cout<<"Time difference is "<<(dw2-dw1)<<" milliSeconds"<<endl;

}