Jak wyzerować funkcję w milisekundach bez boost :: timer

Question

Używam boost 1.46, który nie zawiera boost :: timer, w jaki inny sposób mogę zmienić czas moich funkcji.

Jestem obecnie to robi:

time_t now = time(0); 
<some stuff> 
time_t after = time(0); 

cout << after - now << endl; 

ale to daje odpowiedź w ciągu kilku sekund, więc jeśli funkcja przyjmuje < 1s wyświetla 0.

Dzięki

Answer 1

w Linuksie lub Windows:

#include <ctime> 
#include <iostream> 

int 
main(int, const char**) 
{ 
    std::clock_t start; 

    start = std::clock(); 
    // your test 
    std::cout << "Time: " << (std::clock() - start)/(double)(CLOCKS_PER_SEC/1000) << " ms" << std::endl; 
    return 0; 
} 

Powodzenia;)

Answer 2

Okazuje się, że istnieje wersja czasu w fazie 1.42 (tylko w innym miejscu). Dzięki @jogojapan za wskazanie go.

Można to zrobić tak:

#include <boost/timer.hpp> 

timer t; 
<some stuff> 
std::cout << t.elapsed() << std::endl; 

Lub alternatywnie za pomocą std libs jak @Quentin Perez wskazał (a ja przyjąć jako to, co było pierwotnie zadawane)

Answer 3

Można użyć długo trzymać aktualną wartość czasu jako wartość początkową, a następnie przekonwertować bieżący czas na podwójne. tutaj jest fragment kodu do wykorzystania jako przykład.

#include <iostream> 
#include <stdlib.h> 
#include <time.h> 
#include <sys/types.h> 
#include <sys/timeb.h> 
int main() 
{ 

struct  _timeb tStruct; 
double  thisTime; 
bool  done = false; 
long  startTime; 

struct _timeb 
{ 
int dstflag; // holds a non-zero value if daylight saving time is in effect 
long millitm; // time in milliseconds since the last one-second hack 
long time;  // time in seconds since 00:00:00 1/1/1970 
long timezone; // difference in minutes moving west from UTC 

}; 

    _ftime(&tStruct); // Get start time 

thisTime = tStruct.time + (((double)(tStruct.millitm))/1000.0); // Convert to double 
startTime = thisTime;            // Set the starting time (when the function begins) 


while(!done)  // Start an eternal loop 
    { 
    system("cls"); // Clear the screen 
    _ftime(&tStruct); // Get the current time 
    thisTime = tStruct.time + (((double)(tStruct.millitm))/1000.0); // Convert to double 
    // Check for 5 second interval to print status to screen 
    cout << thisTime-startTime; // Print it. 

    } 
} 

Answer 4

Bazując na rozwiązaniu Quentina Pereza, możesz przekazać dowolną funkcję do czasu używając funkcji std :: i lambda.

#include <ctime> 
#include <iostream> 
#include <functional> 

void timeit(std::function<void()> func) { 
    std::clock_t start = std::clock(); 

    func(); 

    int ms = (std::clock() - start)/(double) (CLOCKS_PER_SEC/1000); 

    std::cout << "Finished in " << ms << "ms" << std::endl; 
} 

int main() { 
    timeit([] { 
     for (int i = 0; i < 10; ++i) { 
      std::cout << "i = " << i << std::endl; 
     } 
    }); 

    return 0; 
} 

Answer 5

Korzystanie std::chrono:

#include <chrono> 
#include <thread> 
#include <iostream> 

// There are other clocks, but this is usually the one you want. 
// It corresponds to CLOCK_MONOTONIC at the syscall level. 
using Clock = std::chrono::steady_clock; 
using std::chrono::time_point; 
using std::chrono::duration_cast; 
using std::chrono::milliseconds; 
using namespace std::literals::chrono_literals; 
using std::this_thread::sleep_for; 

int main() 
{ 
    time_point<Clock> start = Clock::now(); 
    sleep_for(500ms); 
    time_point<Clock> end = Clock::now(); 
    milliseconds diff = duration_cast<milliseconds>(end - start); 
    std::cout << diff.count() << "ms" << std::endl; 
} 

std::chrono jest C++ 11, std::literals jest w C++ 14 (w przeciwnym razie trzeba milliseconds(500)).