Comment utiliser clock () en C ++

Comment dois - je appeler clock()à C++?

Par exemple, je souhaite tester le temps nécessaire à une recherche linéaire pour trouver un élément donné dans un tableau.

#include <iostream>
#include <cstdio>
#include <ctime>

int main() {
    std::clock_t start;
    double duration;

    start = std::clock();

    /* Your algorithm here */

    duration = ( std::clock() - start ) / (double) CLOCKS_PER_SEC;

    std::cout<<"printf: "<< duration <<'\n';
}

Une solution alternative, portable et plus précise, disponible depuis C ++ 11, consiste à utiliser std::chrono.

Voici un exemple:

#include <iostream>
#include <chrono>
typedef std::chrono::high_resolution_clock Clock;

int main()
{
    auto t1 = Clock::now();
    auto t2 = Clock::now();
    std::cout << "Delta t2-t1: " 
              << std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count()
              << " nanoseconds" << std::endl;
}

Lancer ceci sur ideone.com m'a donné:

Delta t2-t1: 282 nanoseconds

clock()renvoie le nombre de coups d'horloge depuis le démarrage de votre programme. Il existe une constante associée CLOCKS_PER_SEC, qui vous indique le nombre de coups d'horloge en une seconde. Ainsi, vous pouvez tester n'importe quelle opération comme celle-ci:

clock_t startTime = clock();
doSomeOperation();
clock_t endTime = clock();
clock_t clockTicksTaken = endTime - startTime;
double timeInSeconds = clockTicksTaken / (double) CLOCKS_PER_SEC;

Sur Windows au moins, le seul mécanisme de mesure pratiquement précis est QueryPerformanceCounter (QPC). std :: chrono est implémenté en l'utilisant (depuis VS2015, si vous l'utilisez), mais il n'est pas aussi précis que l'utilisation directe de QueryPerformanceCounter. En particulier, il est prétendu que le rapport à une granularité de 1 nanoseconde n'est absolument pas correct. Donc, si vous mesurez quelque chose qui prend très peu de temps (et votre cas pourrait bien être un tel cas), vous devriez utiliser QPC, ou l'équivalent pour votre système d'exploitation. Je me suis heurté à cela lors de la mesure des latences de cache, et j'ai noté quelques notes que vous pourriez trouver utiles, ici; https://github.com/jarlostensen/notesandcomments/blob/master/stdchronovsqcp.md

#include <iostream>
#include <ctime>
#include <cstdlib> //_sleep()  --- just a function that waits a certain amount of milliseconds

using namespace std;

int main()
{

    clock_t cl;     //initializing a clock type

    cl = clock();   //starting time of clock

    _sleep(5167);   //insert code here

    cl = clock() - cl;  //end point of clock

    _sleep(1000);   //testing to see if it actually stops at the end point

    cout << cl/(double)CLOCKS_PER_SEC << endl;  //prints the determined ticks per second (seconds passed)


    return 0;
}

//outputs "5.17"

Vous pourriez probablement être intéressé par une minuterie comme celle-ci: H: M: S. Msec.

le code sous Linux OS:

#include <iostream>
#include <unistd.h>

using namespace std;
void newline(); 

int main() {

int msec = 0;
int sec = 0;
int min = 0;
int hr = 0;


//cout << "Press any key to start:";
//char start = _gtech();

for (;;)
{
        newline();
                if(msec == 1000)
                {
                        ++sec;
                        msec = 0;
                }
                if(sec == 60)
                {
                        ++min;
                        sec = 0; 
                }
                if(min == 60)
                {
                        ++hr;
                        min = 0;
                }
        cout << hr << " : " << min << " : " << sec << " . " << msec << endl;
        ++msec;
        usleep(100000); 

}

    return 0;
}

void newline()
{
        cout << "\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
}

vous pouvez mesurer la durée de fonctionnement de votre programme. Les fonctions suivantes permettent de mesurer le temps CPU depuis le démarrage du programme:

• Horloge C ++ (double) () / HORLOGES PAR SEC avec ctime inclus.
• python time.clock () renvoie une valeur à virgule flottante en secondes.
• Java System.nanoTime () renvoie une valeur longue en nanosecondes.

ma référence : Algorithms toolbox semaine 1 cours faisant partie de la spécialisation des structures de données et des algorithmes par l'Université de Californie à San Diego et la National Research University Higher School of Economics

afin que vous puissiez ajouter cette ligne de code après votre algorithme

cout << (double)clock() / CLOCKS_PER_SEC ;

Sortie attendue: la sortie représentant le nombre de clock ticks per second