Cómo usar el reloj() en C++

Question

¿Cómo llamo al clock() en C++?

Por ejemplo, quiero comprobar cuánto tiempo lleva una búsqueda lineal para encontrar un elemento determinado en una matriz.

Answer 1

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

Answer 2

clock() devuelve la cantidad de marcas de reloj desde que se inició el programa. Hay una constante relacionada, CLOCKS_PER_SEC, que le indica cuántas marcas de reloj se producen en un segundo. Por lo tanto, puede probar cualquier operación como ésta:

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

Answer 3

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

Answer 4

Una solución alternativa, que es portátil y con mayor precisión, disponible desde C++ 11, es el uso de std::chrono.

Aquí se muestra un ejemplo:

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

La ejecución de este en ideone.com me dio:

Delta t2-t1: 282 nanoseconds 

Answer 5

Probablemente usted podría estar interesado en temporizador de la siguiente manera: H: M: S. Msec.

el código en el 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"; 
} 

Answer 6

En Windows, al menos, la práctica exacta mecanismo de medición única es QueryPerformanceCounter (QPC). std :: chrono está implementado usándolo (desde VS2015, si lo usa), pero es no preciso en el mismo grado que con QueryPerformanceCounter directamente. En particular, su afirmación de informar a una granularidad de 1 nanosegundo no es absolutamente correcto. Por lo tanto, si está midiendo algo que lleva muy poco tiempo (y su caso podría ser un caso así), entonces debe usar QPC o el equivalente para su sistema operativo. Me enfrenté a esto al medir las latencias de caché, y anoté algunas notas que pueden ser útiles aquí; https://github.com/jarlostensen/notesandcomments/blob/master/stdchronovsqcp.md