Come usare clock () in C ++

Come chiamare clock()in C++?

Ad esempio, voglio testare quanto tempo impiega una ricerca lineare per trovare un determinato elemento in un array.

#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';
}

Una soluzione alternativa, portatile e con maggiore precisione, disponibile dal C ++ 11, è l'utilizzo std::chrono.

Ecco un esempio:

#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;
}

Eseguire questo su ideone.com mi ha dato:

Delta t2-t1: 282 nanoseconds

clock()restituisce il numero di tick dell'orologio dall'inizio del programma. Esiste una costante correlata CLOCKS_PER_SEC, che indica quanti tick di clock si verificano in un secondo. Pertanto, è possibile testare qualsiasi operazione come questa:

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

Almeno su Windows, l' unico meccanismo di misurazione praticamente accurato è QueryPerformanceCounter (QPC). std :: crono è implementato usando (dal VS2015, se si utilizza questo), ma è non è preciso nella stessa misura come l'utilizzo direttamente QueryPerformanceCounter. In particolare si afferma che la granularità a 1 nanosecondo non è assolutamente corretta. Quindi, se stai misurando qualcosa che richiede un tempo molto breve (e il tuo caso potrebbe essere solo un caso del genere), allora dovresti usare QPC o l'equivalente per il tuo sistema operativo. Mi sono imbattuto in questo durante la misurazione delle latenze della cache e ho annotato alcune note che potresti trovare utili, qui; 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"

Probabilmente potresti essere interessato a un timer come questo: H: M: S. Msec.

il codice nel sistema operativo Linux:

#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";
}

puoi misurare la durata del tuo programma. Le seguenti funzioni aiutano a misurare il tempo della CPU dall'inizio del programma:

• C ++ (double) clock () / CLOCKS AL SEC con ctime incluso.
• python time.clock () restituisce il valore in virgola mobile in secondi.
• Java System.nanoTime () restituisce un valore lungo in nanosecondi.

il mio riferimento : Algorithms toolbox settimana 1 corso parte della specializzazione in strutture di dati e algoritmi della University of California San Diego e della National Research University Higher School of Economics

così puoi aggiungere questa riga di codice dopo il tuo algoritmo

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

Uscita prevista: l'uscita che rappresenta il numero di clock ticks per second