C ++ 'da şimdiki saat ve tarih nasıl alınır?

C ++ 'da geçerli tarih ve saati almanın platformlar arası bir yolu var mı?

C ++ 11'de şunları kullanabilirsiniz: std::chrono::system_clock::now()

Örnek ( en.cppreference.com adresinden kopyalanmıştır ):

#include <iostream>
#include <chrono>
#include <ctime>    

int main()
{
    auto start = std::chrono::system_clock::now();
    // Some computation here
    auto end = std::chrono::system_clock::now();

    std::chrono::duration<double> elapsed_seconds = end-start;
    std::time_t end_time = std::chrono::system_clock::to_time_t(end);

    std::cout << "finished computation at " << std::ctime(&end_time)
              << "elapsed time: " << elapsed_seconds.count() << "s\n";
}

Bu, şöyle bir şey yazdırmalıdır:

finished computation at Mon Oct  2 00:59:08 2017
elapsed time: 1.88232s

C ++, tarih / saat işlevlerini C ile paylaşır. Tm yapısı , bir C ++ programcısıyla çalışmak için muhtemelen en kolay olanıdır - aşağıdaki günün tarihi yazdırılır:

#include <ctime>
#include <iostream>

int main() {
    std::time_t t = std::time(0);   // get time now
    std::tm* now = std::localtime(&t);
    std::cout << (now->tm_year + 1900) << '-' 
         << (now->tm_mon + 1) << '-'
         <<  now->tm_mday
         << "\n";
}

Geçerli tarih / saati almak için aşağıdaki platformlar arası kodu deneyebilirsiniz:

#include <iostream>
#include <string>
#include <stdio.h>
#include <time.h>

// Get current date/time, format is YYYY-MM-DD.HH:mm:ss
const std::string currentDateTime() {
    time_t     now = time(0);
    struct tm  tstruct;
    char       buf[80];
    tstruct = *localtime(&now);
    // Visit http://en.cppreference.com/w/cpp/chrono/c/strftime
    // for more information about date/time format
    strftime(buf, sizeof(buf), "%Y-%m-%d.%X", &tstruct);

    return buf;
}

int main() {
    std::cout << "currentDateTime()=" << currentDateTime() << std::endl;
    getchar();  // wait for keyboard input
}

Çıktı:

currentDateTime()=2012-05-06.21:47:59

Tarih / saat biçimi hakkında daha fazla bilgi için lütfen burayı ziyaret edin

std C kütüphaneleri sağlar time(). Bu dönemden saniye cinsindendir ve tarihe ve H:M:Sstandart C işlevleri kullanılarak dönüştürülebilir . Boost ayrıca kontrol edebileceğiniz bir saat / tarih kütüphanesine sahiptir.

time_t  timev;
time(&timev);

C ++ standart kitaplığı uygun bir tarih türü sağlamaz. C ++, yerelleştirmeyi dikkate alan birkaç tarih / saat giriş ve çıkış işlevi ile birlikte C'den tarih ve saat manipülasyonu için yapıları ve işlevleri devralır.

// Current date/time based on current system
time_t now = time(0);

// Convert now to tm struct for local timezone
tm* localtm = localtime(&now);
cout << "The local date and time is: " << asctime(localtm) << endl;

// Convert now to tm struct for UTC
tm* gmtm = gmtime(&now);
if (gmtm != NULL) {
cout << "The UTC date and time is: " << asctime(gmtm) << endl;
}
else {
cerr << "Failed to get the UTC date and time" << endl;
return EXIT_FAILURE;
}

Eski bir soru için yeni cevap:

Soru, hangi saat diliminde belirtilmez. İki makul olasılık vardır:

1. UTC'de.
2. Bilgisayarın yerel saat diliminde.

1 için, bu tarih kütüphanesini ve aşağıdaki programı kullanabilirsiniz:

#include "date.h"
#include <iostream>

int
main()
{
    using namespace date;
    using namespace std::chrono;
    std::cout << system_clock::now() << '\n';
}

Hangi benim için çıktı:

2015-08-18 22:08:18.944211

Tarih kütüphanesi sadece için bir akış operatörü ekler std::chrono::system_clock::time_point. Ayrıca başka birçok güzel işlevsellik ekler, ancak bu basit programda kullanılmaz.

2'yi (yerel saat) tercih ederseniz , tarih kütüphanesinin üzerine inşa edilmiş bir saat dilimi kütüphanesi vardır . Bu kütüphanelerin her ikisi de derleyicinin C ++ 11 veya C ++ 14'ü desteklediği varsayılarak açık kaynak ve çapraz platformdur .

#include "tz.h"
#include <iostream>

int
main()
{
    using namespace date;
    using namespace std::chrono;
    auto local = make_zoned(current_zone(), system_clock::now());
    std::cout << local << '\n';
}

Hangi benim için sadece çıktı:

2015-08-18 18:08:18.944211 EDT

Elde edilen sonuç türü make_zoneda, date::zoned_timea bir eşleştirme olan date::time_zoneve std::chrono::system_clock::time_point. Bu çift yerel bir zamanı temsil eder, ancak nasıl sorguladığınıza bağlı olarak UTC'yi de temsil edebilir.

Yukarıdaki çıktı ile, bilgisayarımın şu anda UTC -4h ve EDT kısaltması ile bir saat diliminde olduğunu görebilirsiniz.

Başka bir saat dilimi isteniyorsa, bu da gerçekleştirilebilir. Örneğin, Sydney, Avustralya'da geçerli saati bulmak için değişkenin yapısını şu şekilde değiştirin local:

auto local = make_zoned("Australia/Sydney", system_clock::now());

Ve çıktı şu şekilde değişir:

2015-08-19 08:08:18.944211 AEST

C ++ 20 Güncelleştirmesi

Bu kütüphane artık büyük ölçüde C ++ 20 için benimsenmiştir. Ad alanı datekayboldu ve std::chronoşimdi her şey ad alanında . Ve kullanmak zoned_timeyerine make_time. Başlıklarını Bırak "date.h"ve "tz.h"sadece kullanmak <chrono>.

Bunu yazarken, bazı platformlarda kısmi uygulamalar ortaya çıkmaya başlıyor.

(Diğer Google çalışanları için)

Ayrıca Boost :: date_time :

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

boost::posix_time::ptime date_time = boost::posix_time::microsec_clock::universal_time();

auto time = std::time(nullptr);
std::cout << std::put_time(std::localtime(&time), "%F %T%z"); // ISO 8601 format.

std::time()Veya std::chrono::system_clock::now()(veya başka bir saat türü ) kullanarak geçerli saati alın .

std::put_time()(C ++ 11) ve strftime()(C) bu zamanların çıktısını almak için birçok biçimlendirici sunar.

#include <iomanip>
#include <iostream>

int main() {
    auto time = std::time(nullptr);
    std::cout
        // ISO 8601: %Y-%m-%d %H:%M:%S, e.g. 2017-07-31 00:42:00+0200.
        << std::put_time(std::gmtime(&time), "%F %T%z") << '\n'
        // %m/%d/%y, e.g. 07/31/17
        << std::put_time(std::gmtime(&time), "%D"); 
}

Formatlayıcıların sırası önemlidir:

std::cout << std::put_time(std::gmtime(&time), "%c %A %Z") << std::endl;
// Mon Jul 31 00:00:42 2017 Monday GMT
std::cout << std::put_time(std::gmtime(&time), "%Z %c %A") << std::endl;
// GMT Mon Jul 31 00:00:42 2017 Monday

Biçimlendiricileri strftime()benzer:

char output[100];
if (std::strftime(output, sizeof(output), "%F", std::gmtime(&time))) {
    std::cout << output << '\n'; // %Y-%m-%d, e.g. 2017-07-31
}

Genellikle büyük harf biçimlendirici "tam sürüm" anlamına gelir ve küçük harf kısaltma anlamına gelir (örn. Y: 2017, y: 17).

Yerel ayarlar çıktıyı değiştirir:

#include <iomanip>
#include <iostream>
int main() {
    auto time = std::time(nullptr);
    std::cout << "undef: " << std::put_time(std::gmtime(&time), "%c") << '\n';
    std::cout.imbue(std::locale("en_US.utf8"));
    std::cout << "en_US: " << std::put_time(std::gmtime(&time), "%c") << '\n';
    std::cout.imbue(std::locale("en_GB.utf8"));
    std::cout << "en_GB: " << std::put_time(std::gmtime(&time), "%c") << '\n';
    std::cout.imbue(std::locale("de_DE.utf8"));
    std::cout << "de_DE: " << std::put_time(std::gmtime(&time), "%c") << '\n';
    std::cout.imbue(std::locale("ja_JP.utf8"));
    std::cout << "ja_JP: " << std::put_time(std::gmtime(&time), "%c") << '\n';
    std::cout.imbue(std::locale("ru_RU.utf8"));
    std::cout << "ru_RU: " << std::put_time(std::gmtime(&time), "%c");        
}

Olası çıktı ( Coliru , Derleyici Gezgini ):

undef: Tue Aug  1 08:29:30 2017
en_US: Tue 01 Aug 2017 08:29:30 AM GMT
en_GB: Tue 01 Aug 2017 08:29:30 GMT
de_DE: Di 01 Aug 2017 08:29:30 GMT
ja_JP: 2017年08月01日 08時29分30秒
ru_RU: Вт 01 авг 2017 08:29:30

std::gmtime()UTC'ye dönüştürmek için kullandım . std::localtime()yerel saate dönüştürmek için sağlanmıştır.

Bu dikkate alın asctime()/ ctime()hemen kaldırıldı ve diğer cevaplar bahsedildi işaretlenir strftime()tercih edilmelidir.

#include <stdio.h>
#include <time.h>

int main ()
{
  time_t rawtime;
  struct tm * timeinfo;

  time ( &rawtime );
  timeinfo = localtime ( &rawtime );
  printf ( "Current local time and date: %s", asctime (timeinfo) );

  return 0;
} 

Evet ve şu anda yerleşik olan yerel ayar tarafından belirtilen biçimlendirme kurallarıyla yapabilirsiniz:

#include <iostream>
#include <iterator>
#include <string>

class timefmt
{
public:
    timefmt(std::string fmt)
        : format(fmt) { }

    friend std::ostream& operator <<(std::ostream &, timefmt const &);

private:
    std::string format;
};

std::ostream& operator <<(std::ostream& os, timefmt const& mt)
{
    std::ostream::sentry s(os);

    if (s)
    {
        std::time_t t = std::time(0);
        std::tm const* tm = std::localtime(&t);
        std::ostreambuf_iterator<char> out(os);

        std::use_facet<std::time_put<char>>(os.getloc())
            .put(out, os, os.fill(),
                 tm, &mt.format[0], &mt.format[0] + mt.format.size());
    }

    os.width(0);

    return os;
}

int main()
{
    std::cout << timefmt("%c");
}

Çıktı: Fri Sep 6 20:33:31 2013

C ++ 11 zaman sınıfını kullanabilirsiniz:

    #include <iostream>
    #include <iomanip>
    using namespace std;

    int main() {

       time_t now = chrono::system_clock::to_time_t(chrono::system_clock::now());
       cout << put_time(localtime(&now), "%F %T") <<  endl;
      return 0;
     }

çıktı:

2017-08-25 12:30:08

Her zaman __TIMESTAMP__önişlemci makrosu vardır.

#include <iostream>

using namespace std

void printBuildDateTime () {
    cout << __TIMESTAMP__ << endl;
}

int main() {
    printBuildDateTime();
}

örnek: Paz 13 Nis 11:28:08 2014

Ayrıca doğrudan şunları da kullanabilirsiniz ctime():

#include <stdio.h>
#include <time.h>

int main ()
{
  time_t rawtime;
  struct tm * timeinfo;

  time ( &rawtime );
  printf ( "Current local time and date: %s", ctime (&rawtime) );

  return 0;
} 

Bu bağlantı benim uygulama için oldukça yararlı buldum: C ++ Tarih ve Saat

İşte benim uygulama, net bir "YYYYMMDD HHMMSS" çıkış biçimi almak için kullandığım kod. Param, UTC ve yerel saat arasında geçiş yapmak içindir. İhtiyaçlarınıza göre kodumu kolayca değiştirebilirsiniz.

#include <iostream>
#include <ctime>

using namespace std;

/**
 * This function gets the current date time
 * @param useLocalTime true if want to use local time, default to false (UTC)
 * @return current datetime in the format of "YYYYMMDD HHMMSS"
 */

string getCurrentDateTime(bool useLocalTime) {
    stringstream currentDateTime;
    // current date/time based on current system
    time_t ttNow = time(0);
    tm * ptmNow;

    if (useLocalTime)
        ptmNow = localtime(&ttNow);
    else
        ptmNow = gmtime(&ttNow);

    currentDateTime << 1900 + ptmNow->tm_year;

    //month
    if (ptmNow->tm_mon < 9)
        //Fill in the leading 0 if less than 10
        currentDateTime << "0" << 1 + ptmNow->tm_mon;
    else
        currentDateTime << (1 + ptmNow->tm_mon);

    //day
    if (ptmNow->tm_mday < 10)
        currentDateTime << "0" << ptmNow->tm_mday << " ";
    else
        currentDateTime <<  ptmNow->tm_mday << " ";

    //hour
    if (ptmNow->tm_hour < 10)
        currentDateTime << "0" << ptmNow->tm_hour;
    else
        currentDateTime << ptmNow->tm_hour;

    //min
    if (ptmNow->tm_min < 10)
        currentDateTime << "0" << ptmNow->tm_min;
    else
        currentDateTime << ptmNow->tm_min;

    //sec
    if (ptmNow->tm_sec < 10)
        currentDateTime << "0" << ptmNow->tm_sec;
    else
        currentDateTime << ptmNow->tm_sec;


    return currentDateTime.str();
}

Çıktı (UTC, EST):

20161123 000454
20161122 190454

Bu G ++ ile çalışır Bu size yardımcı olup olmadığından emin değilim. Program çıktısı:

The current time is 11:43:41 am
The current date is 6-18-2015 June Wednesday 
Day of month is 17 and the Month of year is 6,
also the day of year is 167 & our Weekday is 3.
The current year is 2015.

Kod:

#include <ctime>
#include <iostream>
#include <string>
#include <stdio.h>
#include <time.h>

using namespace std;

const std::string currentTime() {
time_t now = time(0);
struct tm tstruct;
char buf[80];
tstruct = *localtime(&now);
strftime(buf, sizeof(buf), "%H:%M:%S %P", &tstruct);
return buf;
}

const std::string currentDate() {
time_t now = time(0);
struct tm tstruct;
char buf[80];
tstruct = *localtime(&now);
strftime(buf, sizeof(buf), "%B %A ", &tstruct);
return buf;
}

int main() {
    cout << "\033[2J\033[1;1H"; 
std:cout << "The current time is " << currentTime() << std::endl;
    time_t t = time(0);   // get time now
    struct tm * now = localtime( & t );
    cout << "The current date is " << now->tm_mon + 1 << '-' 
         << (now->tm_mday  + 1) << '-'
         <<  (now->tm_year + 1900) 
         << " " << currentDate() << endl; 

 cout << "Day of month is " << (now->tm_mday) 
      << " and the Month of year is " << (now->tm_mon)+1 << "," << endl;
    cout << "also the day of year is " << (now->tm_yday) 
         << " & our Weekday is " << (now->tm_wday) << "." << endl;
    cout << "The current year is " << (now->tm_year)+1900 << "." 
         << endl;
 return 0;  
}

Bu benim için Linux (RHEL) ve Windows (x64) g ++ ve OpenMP'yi hedefledi:

#include <ctime>
#include <iostream>
#include <string>
#include <locale>

////////////////////////////////////////////////////////////////////////////////
//
//  Reports a time-stamped update to the console; format is:
//       Name: Update: Year-Month-Day_of_Month Hour:Minute:Second
//
////////////////////////////////////////////////////////////////////////////////
//
//  [string] strName  :  name of the update object
//  [string] strUpdate:  update descripton
//          
////////////////////////////////////////////////////////////////////////////////

void ReportTimeStamp(string strName, string strUpdate)
{
    try
    {
        #ifdef _WIN64
            //  Current time
            const time_t tStart = time(0);
            //  Current time structure
            struct tm tmStart;

            localtime_s(&tmStart, &tStart);

            //  Report
            cout << strName << ": " << strUpdate << ": " << (1900 + tmStart.tm_year) << "-" << tmStart.tm_mon << "-" << tmStart.tm_mday << " " << tmStart.tm_hour << ":" << tmStart.tm_min << ":" << tmStart.tm_sec << "\n\n";
        #else
            //  Current time
            const time_t tStart = time(0);
            //  Current time structure
            struct tm* tmStart;

            tmStart = localtime(&tStart);

            //  Report
            cout << strName << ": " << strUpdate << ": " << (1900 + tmStart->tm_year) << "-" << tmStart->tm_mon << "-" << tmStart->tm_mday << " " << tmStart->tm_hour << ":" << tmStart->tm_min << ":" << tmStart->tm_sec << "\n\n";
        #endif

    }
    catch (exception ex)
    {
        cout << "ERROR [ReportTimeStamp] Exception Code:  " << ex.what() << "\n";
    }

    return;
}

Aşağıdaki kullanabilirsiniz kodu almak için mevcut sistem tarihini ve zamanını içinde C ++ :

    #include <iostream>
    #include <time.h> //It may be #include <ctime> or any other header file depending upon
                     // compiler or IDE you're using 
    using namespace std;

    int main() {
       // current date/time based on current system
       time_t now = time(0);

       // convert now to string form
       string dt = ctime(&now);

       cout << "The local date and time is: " << dt << endl;
    return 0;
    }

Not: Daha fazla bilgi için bu siteyi ziyaret edin .

Ffead-cpp çeşitli görevler için birden fazla yarar sınıfları sağlar, böyle bir sınıftır tarihi tarih aritmetik hakkı tarihi operasyonlarından bir çok özellik sağlayan sınıf, aynı zamanda bir var Zamanlayıcı zamanlama işlemleri için sağlanan sınıfı. Aynı göz atabilirsiniz.

http://www.cplusplus.com/reference/ctime/strftime/

Bu yerleşik makul bir dizi seçenek sunuyor gibi görünüyor.

localtime_s () sürümü:

#include <stdio.h>
#include <time.h>

int main ()
{
  time_t current_time;
  struct tm  local_time;

  time ( &current_time );
  localtime_s(&local_time, &current_time);

  int Year   = local_time.tm_year + 1900;
  int Month  = local_time.tm_mon + 1;
  int Day    = local_time.tm_mday;

  int Hour   = local_time.tm_hour;
  int Min    = local_time.tm_min;
  int Sec    = local_time.tm_sec;

  return 0;
} 

#include <iostream>
#include <chrono>
#include <string>
#pragma warning(disable: 4996)
// Ver: C++ 17 
// IDE: Visual Studio
int main() {
    using namespace std; 
    using namespace chrono;
    time_point tp = system_clock::now();
    time_t tt = system_clock::to_time_t(tp);
    cout << "Current time: " << ctime(&tt) << endl;
    return 0;
}

#include <Windows.h>

void main()
{
     //Following is a structure to store date / time

SYSTEMTIME SystemTime, LocalTime;

    //To get the local time

int loctime = GetLocalTime(&LocalTime);

    //To get the system time

int systime = GetSystemTime(&SystemTime)

}

Şunları kullanabilirsiniz boost:

#include <boost/date_time/gregorian/gregorian.hpp>
#include <iostream>
using namespace boost::gregorian;

int main()
{
    date d = day_clock::universal_day();
    std::cout << d.day() << " " << d.month() << " " << d.year();
}