UNE CLASSE DE CHRONO QUI VA JUSQU'A LA NANOSECONDE !

//CPerfChrono.h
//Classe PerfChrono qui permet de mesurer le temps necessaire pour effectuer une portion de code

#include <windows.h> //Pour les fonctions QueryPerformanceCounter et QueryPerformanceFrequency

#define Ms 1000
#define Us 1000000
#define Ns 1000000000

class PerfChrono
{
    __int64 freq, t0; //la frequence de l'horloge et le temps initial

public:
    PerfChrono() //Le constructeur qui va récupérer la fréquence de l'horloge
    {
        QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
        //On passe en paramètre à QueryPerformanceFrequency une structure LARGE_INTEGER qui est composée d'un __int64
        //Cette structure(içi freq) va contenir la frequence de l'horloge
    }

    void Start()
    {
        QueryPerformanceCounter((LARGE_INTEGER*)&t0);
        //On fait pareil qu'au dessus mais cette fois t0 va contenir le temps au debut du chronometrage
    }

    DWORD GetDiffMs()
    {
        __int64 t1; //le temps au moment de l'execution de la fonction
        QueryPerformanceCounter((LARGE_INTEGER*)&t1); //On assigne à t1 le temp au moment de l'execution de la fonction
        return (DWORD)(((t1 - t0) * 1000) / freq); //La forumle qui permet de calculer le temps écoulé
        //Pour avoir le temps écoulé, on retranche le temps au moment de la fonction du temps au debut du chrono, 
        //Puis on le multiplie par la précision (1000) et on le divise par la frequence.
    }

    DWORD GetDiffUs() //Us pour µs
    {
        __int64 t1; //le temps au moment de l'execution de la fonction
        QueryPerformanceCounter((LARGE_INTEGER*)&t1); //On assigne à t1 le temp au moment de l'execution de la fonction
        return (DWORD)(((t1 - t0) * 1000000) / freq); //La forumle qui permet de calculer le temps écoulé
        //Pour avoir le temps écoulé, on retranche le temps au moment de la fonction du temps au debut du chrono, 
        //Puis on le multiplie par la précision (1000000) et on le divise par la frequence.
    }

    DWORD GetDiffNs()
    {
        __int64 t1; //le temps au moment de l'execution de la fonction
        QueryPerformanceCounter((LARGE_INTEGER*)&t1); //On assigne à t1 le temp au moment de l'execution de la fonction
        return (DWORD)(((t1 - t0) * 1000000000) / freq); //La forumle qui permet de calculer le temps écoulé
        //Pour avoir le temps écoulé, on retranche le temps au moment de la fonction du temps au debut du chrono, 
        //Puis on le multiplie par la précision (1000000000) et on le divise par la frequence.
    }

    DWORD GetDiff(UINT unit)
    {
        __int64 t1;
        QueryPerformanceCounter((LARGE_INTEGER*)&t1);
        return (DWORD)(((t1 - t0) * unit) / freq);
    }

    DWORD GetFreq()
    {
        return (DWORD)freq;
    }
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Test.cpp
//Test de la classe de chrono

#include "CPerfChrono.h"
#include <iostream>

using namespace std;

int main(int argc, char *argv[], char *envp[])
{
    PerfChrono chrono;
    cout<<"Frequence de l'horloge : "<<chrono.GetFreq()<<" Hz."<<endl;
    cout<<"Testons la précision de cette horloge :"<<endl;
    cout<<"10 millisecondes = ";
    chrono.Start();
    Sleep(10);
    cout<<chrono.GetDiffNs()<<endl;
    return 0;
}