Comment obtenir l'heure actuelle en C++?
Existe-t-il un moyen multi-plateforme d'obtenir la date et l'heure actuelles en C++?
En C++ 11, vous pouvez utiliser std::chrono::system_clock::now()
Exemple (copié de en.cppreference.com ):
#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";
}
Cela devrait imprimer quelque chose comme ceci:
finished computation at Mon Oct 2 00:59:08 2017
elapsed time: 1.88232s
C++ partage ses fonctions de date/heure avec C. La structure tm est probablement la méthode la plus simple à utiliser pour un programmeur C++: les dates suivantes sont affichées:
#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";
}
Vous pouvez essayer le code multiplate-forme suivant pour obtenir la date et l'heure actuelles:
#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
}
Sortie:
currentDateTime()=2012-05-06.21:47:59
Veuillez visiter ici pour plus d'informations sur le format de date/heure
les bibliothèques std C fournissent time() . C’est à quelques secondes de l’époque et peut être converti en date et en H:M:S à l’aide de fonctions standard. Boost a aussi une bibliothèque d’heures/de dates que vous pouvez vérifier.
time_t timev;
time(&timev);
la bibliothèque standard C++ ne fournit pas un type de date approprié. C++ hérite des structures et des fonctions de manipulation de la date et de l'heure pour la manipulation de la date et de l'heure, ainsi que de quelques fonctions d'entrée et de sortie de date/heure prenant en compte la localisation.
// 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;
}
Nouvelle réponse à une vieille question:
La question ne précise pas dans quel fuseau horaire. Il y a deux possibilités raisonnables:
- En UTC.
- Dans le fuseau horaire local de l'ordinateur.
Pour 1, vous pouvez utiliser cette bibliothèque de dates et le programme suivant:
#include "date.h"
#include <iostream>
int
main()
{
using namespace date;
using namespace std::chrono;
std::cout << system_clock::now() << '\n';
}
Ce qui vient de sortir pour moi:
2015-08-18 22:08:18.944211
La bibliothèque de dates ajoute essentiellement un opérateur de diffusion pour std::chrono::system_clock::time_point. Il ajoute également beaucoup d'autres fonctionnalités de Nice, mais cela n'est pas utilisé dans ce programme simple.
Si vous préférez 2 (heure locale), il existe une bibliothèque timezone qui s’appuie sur la bibliothèque date . Ces deux bibliothèques sont open source et cross platform, en supposant que le compilateur prend en charge C++ 11 ou C++ 14.
#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';
}
Ce qui pour moi vient de sortir:
2015-08-18 18:08:18.944211 EDT
Le type de résultat de make_zoned est un date::zoned_time, qui est une association d'un date::time_zone et d'un std::chrono::system_clock::time_point. Cette paire représente une heure locale, mais peut également représenter une heure UTC, selon la façon dont vous l'interrogez.
Avec la sortie ci-dessus, vous pouvez voir que mon ordinateur est actuellement dans un fuseau horaire avec un décalage UTC de -4h et une abréviation de EDT.
Si vous souhaitez un autre fuseau horaire, vous pouvez également le faire. Par exemple, pour trouver l'heure actuelle à Sydney, en Australie, il suffit de changer la construction de la variable local en:
auto local = make_zoned("Australia/Sydney", system_clock::now());
Et la sortie passe à:
2015-08-19 08:08:18.944211 AEST
(Pour les autres googlers)
Il y a aussi 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();
#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;
}
auto time = std::time(nullptr);
std::cout << std::put_time(std::localtime(&time), "%F %T%z"); // ISO 8601 format.
Obtenez l'heure actuelle en utilisant std::time() ou std::chrono::system_clock::now() (ou un autre type d'horloge ).
std::put_time() (C++ 11) et strftime() (C) offrent beaucoup de formateurs pour afficher ces temps.
#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");
}
La séquence des formateurs compte:
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
Les formateurs de strftime() sont similaires:
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
}
Souvent, le formateur majuscule signifie "version complète" et l'abréviation minuscule (par exemple, Y: 2017, y: 17).
Les paramètres régionaux modifient le résultat:
#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");
}
Sortie possible ( Coliru , Explorateur de compilateur ):
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
J'ai utilisé std::gmtime() pour la conversion en UTC. std::localtime() est fourni pour convertir en heure locale.
Tenez compte du fait que asctime() / ctime() qui ont été mentionnés dans d'autres réponses sont marqués comme obsolètes maintenant et que strftime() devrait être préféré.
Oui et vous pouvez le faire avec les règles de formatage spécifiées par les paramètres régionaux actuellement imprégnés:
#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");
}
Sortie:
Fri Sep 6 20:33:31 2013
vous pouvez utiliser la classe temporelle C++ 11:
#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;
}
out mis:
2017-08-25 12:30:08
Il y a toujours la macro de préprocesseur __TIMESTAMP__.
#include <iostream>
using namespace std
void printBuildDateTime () {
cout << __TIMESTAMP__ << endl;
}
int main() {
printBuildDateTime();
}
exemple: dim 13 avr. 11:28:08 2014
J'ai trouvé ce lien très utile pour mon implémentation: Date et heure C++
Voici le code que j'utilise dans mon implémentation, pour obtenir un format de sortie "AAAAMMJJ HHMMSS". Le paramètre est pour basculer entre l'heure UTC et l'heure locale. Vous pouvez facilement modifier mon code pour répondre à vos besoins.
#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();
}
Sortie (UTC, EST):
20161123 000454
20161122 190454
Vous pouvez également utiliser directement 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;
}
Ceci compilé pour moi sur Linux (RHEL) et Windows (x64), ciblant g ++ et OpenMP:
#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;
}
Ffead-cpp fournit plusieurs classes d’utilitaires pour diverses tâches, notamment la classe Date , qui fournit de nombreuses fonctionnalités depuis les opérations sur les dates jusqu'au calcul arithmétique des dates. Il existe également une classe Timer . prévu pour les opérations de chronométrage. Vous pouvez regarder la même chose.
Cela fonctionne avec G ++. Je ne suis pas sûr que cela vous aide. Sortie du programme:
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.
Code:
#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;
}
http://www.cplusplus.com/reference/ctime/strftime/
Cette fonctionnalité semble offrir un ensemble raisonnable d’options.
version localtime_s ():
#include <stdio.h>
#include <time.h>
int main ()
{
time_t current_time;
struct tm local_time;
time ( ¤t_time );
localtime_s(&local_time, ¤t_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;
}
Vous pouvez utiliser le code suivant pour obtenir la date et l'heure système actuelles en 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;
}
PS: Visitez ce site pour plus d’informations.
#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)
}
Vous pouvez utiliser 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();
}