wake-up-neo.com

So drucken Sie die aktuelle Uhrzeit (mit Millisekunden) mit C++/C++ 11

Derzeit verwende ich diesen Code

string now() {
    time_t t = time(0);
    char buffer[9] = {0};

    strftime(buffer, 9, "%H:%M:%S", localtime(&t));
    return string(buffer);
}

zeit formatieren. Ich muss Millisekunden hinzufügen, damit die Ausgabe das Format hat: 16:56:12.321

19
Prospolon

Sie können Posix Time von Boost verwenden.

Sie können boost::posix_time::microsec_clock::local_time() verwenden, um die aktuelle Uhrzeit von einer Mikrosekunden-Auflösung abzurufen:

boost::posix_time::ptime now = boost::posix_time::microsec_clock::local_time();

Dann können Sie den Zeitversatz am aktuellen Tag berechnen (da Ihre Dauerausgabe in der Form <hours>:<minutes>:<seconds>.<milliseconds> vorliegt, gehe ich davon aus, dass sie als aktueller Tagesversatz berechnet werden. Wenn dies nicht der Fall ist, können Sie einen anderen Startpunktfür Dauer/Zeitintervall):

boost::posix_time::time_duration td = now.time_of_day();

Dann können Sie mit .hours(), .minutes(), .seconds() auf die entsprechenden Werte zugreifen.
Leider scheint es keinen .milliseconds() Accessor zu geben, aber es gibt einen .total_milliseconds()-Zugriff. Sie können also eine kleine Subtraktionsberechnung durchführen, um die verbleibenden Millisekunden in der Zeichenfolge formatieren zu lassen.

Dann können Sie sprintf() (oder sprintf()_s, wenn Sie an nicht portablem VC++ - Code interessiert sind) verwenden, um diese Felder in einen unbenutzbaren char-Puffer zu formatieren und diesen unaufbereiteten C-String-Puffer sicher in eine robuste std::string-Instanz zu hüllen.

Siehe den kommentierten Code für weitere Details.

Ausgabe in Konsole ist so etwas wie:

11: 43: 52,276


Beispielcode:

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

#include <stdio.h>      // for sprintf()

#include <iostream>     // for console output
#include <string>       // for std::string

#include <boost/date_time/posix_time/posix_time.hpp>


//-----------------------------------------------------------------------------
// Format current time (calculated as an offset in current day) in this form:
//
//     "hh:mm:ss.SSS" (where "SSS" are milliseconds)
//-----------------------------------------------------------------------------
std::string now_str()
{
    // Get current time from the clock, using microseconds resolution
    const boost::posix_time::ptime now = 
        boost::posix_time::microsec_clock::local_time();

    // Get the time offset in current day
    const boost::posix_time::time_duration td = now.time_of_day();

    //
    // Extract hours, minutes, seconds and milliseconds.
    //
    // Since there is no direct accessor ".milliseconds()",
    // milliseconds are computed _by difference_ between total milliseconds
    // (for which there is an accessor), and the hours/minutes/seconds
    // values previously fetched.
    //
    const long hours        = td.hours();
    const long minutes      = td.minutes();
    const long seconds      = td.seconds();
    const long milliseconds = td.total_milliseconds() -
                              ((hours * 3600 + minutes * 60 + seconds) * 1000);

    //
    // Format like this:
    //
    //      hh:mm:ss.SSS
    //
    // e.g. 02:15:40:321
    //
    //      ^          ^
    //      |          |
    //      123456789*12
    //      ---------10-     --> 12 chars + \0 --> 13 chars should suffice
    //  
    // 
    char buf[40];
    sprintf(buf, "%02ld:%02ld:%02ld.%03ld", 
        hours, minutes, seconds, milliseconds);

    return buf;
}

int main()
{
    std::cout << now_str() << '\n';    
}

///////////////////////////////////////////////////////////////////////////////
17
Mr.C64

Verschwenden Sie nicht Ihre Zeit mit Boost (ich weiß, viele werden durch diese Aussage beleidigt und betrachten es als Häresie). 

Diese Diskussion enthält zwei sehr praktikable Lösungen, bei denen Sie sich nicht in nicht standardmäßigen Bibliotheken von Drittanbietern versklaven müssen.

C++ erlangt Millisekundenzeit unter Linux - clock () scheint nicht richtig zu funktionieren

http://linux.die.net/man/3/clock_gettime

Verweise auf gettimeofday finden Sie hier bei opengroup.org

16
Martin Goff

Sie können boost::posix_time verwenden. Siehe diese SO - Frage . Ex:

boost::posix_time::time_duration diff = tick - now;
diff.total_milliseconds();

Um die aktuelle Uhrzeit zu erhalten:

boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::local_time();
// ('tick' and 'now' are of the type of 't1')

Sie können auch die C++ 11-Chrono verwenden, wenn Sie C++ 11 verwenden können. Ex:

int elapsed_milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();

Um die aktuelle Uhrzeit abzurufen (Sie haben mehrere verschiedene Uhren zur Verfügung, siehe das Dokument):

std::chrono::time_point<std::chrono::system_clock> t2;
t2 = std::chrono::system_clock::now();
// ('start' and 'end' are of the type of 't2')

Für die Zeit in Millisekunden können Sie die Dauer zwischen Mitternacht und der aktuellen Uhrzeit ermitteln. Beispiel mit std :: chrono :

unsigned int millis_since_midnight()
{
    // current time
    std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now();

    // get midnight
    time_t tnow = std::chrono::system_clock::to_time_t(now);
    tm *date = std::localtime(&tnow);
    date->tm_hour = 0;
    date->tm_min = 0;
    date->tm_sec = 0;
    auto midnight = std::chrono::system_clock::from_time_t(std::mktime(date));

    // number of milliseconds between midnight and now, ie current time in millis
    // The same technique can be used for time since Epoch
    return std::chrono::duration_cast<std::chrono::milliseconds>(now - midnight).count();
}
6
Synxis

Ich würde empfehlen, Boost.Chrono anstelle der Boost.Datetime-Bibliothek zu verwenden, da Chrono Teil von C++ 11 wurde. Beispiele hier

3
Andriy Tylychko

Hier ist eine Lösung, die ich ohne Boost gefunden habe

std::string getCurrentTimestamp()
{
using std::chrono::system_clock;
auto currentTime = std::chrono::system_clock::now();
char buffer[80];

auto transformed = currentTime.time_since_Epoch().count() / 1000000;

auto millis = transformed % 1000;

std::time_t tt;
tt = system_clock::to_time_t ( currentTime );
auto timeinfo = localtime (&tt);
strftime (buffer,80,"%F %H:%M:%S",timeinfo);
sprintf(buffer, "%s:%03d",buffer,(int)millis);

return std::string(buffer);
}
0
Enrico Pintus