Comment obtenir l'heure et la date actuelles en C ++?


457

Existe-t-il un moyen multiplateforme pour obtenir la date et l'heure actuelles en C ++?


2
Si Ockonal est toujours actif, il doit modifier la réponse acceptée à l'approche C ++ 11. Cette question semble toujours avoir beaucoup de vues.
JSQuareD


3
@JSQuareD Même en regardant cette question maintenant après tout ce temps, je trouve l'approche C mieux en utilisant la tmstructure. L'approche C ++ 11 ne donne-t-elle pas simplement l'horodatage Unix (le temps depuis l'époque) bien que la question soit d'obtenir la date et l'heure?
anddero

Wow, cette question a 1 110 886 vues! Les gens aiment vraiment C ++!
User123

Réponses:


595

En C ++ 11, vous pouvez utiliser std::chrono::system_clock::now()

Exemple (copié depuis 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

28
Cela devrait être surévalué car c'est le moyen le plus portable et le plus simple du C ++ actuel.
Johannes

4
@Johannes, vient d'ajouter le mien. À ce rythme, cela devrait être la meilleure réponse d'ici le 15 août 2017, 16:31 UTC :-)
Martin Broadhurst

62
Cette réponse est très peu utile sans exemples d'utilisation de la valeur obtenue. Par exemple, comment pouvez-vous l'imprimer, obtenir l'heure locale, comparer avec une autre date / heure?
Steed

32
C'est la pire réponse possible. Cela rend les autres réponses c ++ 11 en double, et pourtant il n'explique rien, étant un «lien uniquement».
v010dya

10
Il n'y a aucun moyen d'aller plus loin que cette réponse. L'OP demandait "Existe-t-il un moyen multiplateforme pour obtenir la date et l'heure actuelles en C ++?" Cette question vous donne exactement cela. Si vous avez des doutes sur la façon d'obtenir un stringfichier streamou sur la façon de le formater correctement time_point<>, allez-y et posez une autre question ou google après.
Tarc

482

C ++ partage ses fonctions date / heure avec C. La structure tm est probablement la plus simple pour un programmeur C ++ - les impressions suivantes indiquent la date d'aujourd'hui:

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

26
À utiliser ctime()avec cette réponse si vous voulez une chaîne de date.
ralphtheninja

3
qu'en est-il de la suppression de l'instance de struct tmest-il possible d'appeler simplement delete dessus?
Petr

4
@Petr vous avez seulement besoin d'appeler delete sur la mémoire allouée à new.
iheanyi

4
ok mais vous obtenez toujours un pointeur de localtime () afin que l'instance de structure soit allouée sur le tas ou non? ce qui signifie qu'il ne sera pas nettoyé à moins que vous ne le fassiez d'une manière ou d'une autre. Je n'ai jamais dit utiliser delete(mot-clé c ++) dessus, je pensais juste qu'il devrait être supprimé d'une manière ou d'une autre :) ou qui va le faire pour vous?
Petr

9
@Petr Vous n'avez pas besoin de le désallouer car il est alloué statiquement, voir ici pour ce sujet stackoverflow.com/questions/8694365/…
Brandin

180

Vous pouvez essayer le code multiplateforme suivant pour obtenir la date / heure actuelle:

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

Production:

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

Veuillez visiter ici pour plus d'informations sur le format date / heure


Bonjour. J'ai un petit problème avec cette allocation "buf" à l'intérieur de la fonction "currentDateTime ()". Comment est-il censé persister après le retour de la fonction? THX.
Léa Massiot

7
Le type de retour est "const std :: string", il est donc renvoyé par valeur, puis une copie du tampon est effectuée, avant de le libérer.
barranquero

3
Pourquoi retourner de la constvaleur? C'est inutile.
Courses de légèreté en orbite

plus 1 pour une solution multiplateforme!
Ziagl

139

Les bibliothèques std C fournissent time(). Ceci est à quelques secondes de l'époque et peut être converti en date et en H:M:Sutilisant des fonctions C standard. Boost possède également une bibliothèque heure / date que vous pouvez vérifier.

time_t  timev;
time(&timev);

24
La réponse ci-dessous a une meilleure structure et fournit un meilleur exemple.
MDTech.us_MAN

2
En outre, il a posé des questions sur C ++ et non sur C.
jterm

2
@jterm c'est ok, C et C ++ partagent exactement la même bibliothèque de temps, c'est une question de noms d'importation différents et c'est tout
Joseph Farah

31

la bibliothèque standard C ++ ne fournit pas un type de date correct. C ++ hérite des structures et des fonctions de manipulation de la date et de l'heure de C, ainsi que de quelques fonctions d'entrée et de sortie date / heure qui prennent 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;
}

25

Nouvelle réponse à une ancienne question:

La question ne précise pas dans quel fuseau horaire. Il existe deux possibilités raisonnables:

  1. En UTC.
  2. 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 streaming pour std::chrono::system_clock::time_point. Il ajoute également beaucoup d'autres fonctionnalités intéressantes, mais qui ne sont pas utilisées dans ce programme simple.

Si vous préférez 2 (l'heure locale), il existe une bibliothèque de fuseaux horaires qui s'appuie sur la bibliothèque de dates . Ces deux bibliothèques sont open source et multiplateforme , 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_zonedest un date::zoned_timequi est un appariement de a date::time_zoneet de a std::chrono::system_clock::time_point. Cette paire représente une heure locale, mais peut également représenter 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 d'EDT.

Si un autre fuseau horaire est souhaité, cela peut également être accompli. Par exemple, pour trouver l'heure actuelle à Sydney, en Australie, il suffit de changer la construction de la variable localen:

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

Et la sortie se transforme en:

2015-08-19 08:08:18.944211 AEST

Mise à jour pour C ++ 20

Cette bibliothèque est maintenant largement adoptée pour C ++ 20. L'espace de noms a datedisparu et tout est std::chronomaintenant dans l'espace de noms . Et utiliser zoned_timeà la place de make_time. Déposez les en-têtes "date.h"et "tz.h"et utilisez simplement <chrono>.

Au moment où j'écris ces lignes, des implémentations partielles commencent à peine à émerger sur certaines plateformes.


Ne devrait pas localtimeme donner l'heure dans mon fuseau horaire?
Jonathan Mee

Oui, vous localtimedonne presque toujours l'heure de votre fuseau horaire local avec une seconde précision. Parfois, il échouera en raison de problèmes de sécurité des threads et ne fonctionnera jamais avec une précision inférieure à la seconde.
Howard Hinnant

19

(Pour les autres googleurs)

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();

16
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 de nombreux formateurs pour sortir 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 est importante:

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 de majuscules signifie "version complète" et les minuscules signifient abréviation (par exemple Y: 2017, y: 17).


Les paramètres régionaux modifient la sortie:

#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 , Compiler Explorer ):

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 de ce qui asctime()/ ctime()qui a été mentionné dans d'autres réponses est marqué comme obsolète maintenant et strftime()devrait être préféré.


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

12

Oui et vous pouvez le faire avec des 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");
}

Production: Fri Sep 6 20:33:31 2013


1
C'est, à mon humble avis, en fait la meilleure réponse, car c'est la seule qui respecte les paramètres locaux, et parce qu'elle est programmée avec une telle attention aux détails (vous ne le voyez pas ostream::sentrysouvent).
DevSolar

@DevSolar Merci. Je ne dirais pas que c'est le meilleur. J'ai vu de meilleures implémentations. Mais je pense que cela suffit pour un exemple :)
0x499602D2

N'a pas compilé pour moi. Étant novice, je ne peux pas expliquer pourquoi.
historystamp

8

vous pouvez utiliser la classe horaire 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;
     }

production:

2017-08-25 12:30:08

6

Il y a toujours la __TIMESTAMP__macro du préprocesseur.

#include <iostream>

using namespace std

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

int main() {
    printBuildDateTime();
}

exemple: dim 13 avr 11:28:08 2014


27
Cela ne fonctionnera pas car TIMESTAMP donnera l'heure de création du fichier plutôt que l'heure actuelle.
feelfree

3
en y repensant, je n'ai aucune idée de pourquoi je me sentais équipé pour répondre à une question C ++
James Robert Albert

1
__TIMESTAMP__est une macro de préprocesseur qui se développe à l'heure actuelle (au moment de la compilation) sous la forme Jjj Mmm Date hh :: mm :: ss aaaa. La __TIMESTAMP__macro peut être utilisée pour fournir des informations sur le moment particulier où un binaire a été créé. Référence: cprogramming.com/reference/preprocessor/__TIMESTAMP__.html
selfboot

4

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

4
dans VS2012 je dois ajouter #define _CRT_SECURE_NO_DEPRECATEavant d'inclure pour faire des compilations de programmes
javapowered

4

J'ai trouvé ce lien assez 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 "YYYYMMDD HHMMSS" clair. Le paramètre est pour basculer entre UTC et l'heure locale. Vous pouvez facilement modifier mon code en fonction de 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

Pourquoi avez-vous demandé si ptmNow->tm_day < 9et non <10?
STF

Je veux qu'un jour (disons le jour X) inférieur à 9 soit 0X (c'est-à-dire 1 -> 01, 9 -> 09) pour remplir l'espace, afin de correspondre à notre conception. Le jour 10 peut simplement être 10 dans la chaîne.
Joe

Vous devez donc demander si c'est <=9parce que vous voulez en inclure également 9.
STF

Remarque J'ai un 1+dans le code. Le jour / mois commence à 0.
Joe

le mois commence à 0, mais le jour commence à 1!
STF

3

Cela fonctionne avec G ++, je ne sais pas si 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;  
}

C'est un bon exemple, mais la ligne 'strftime (buf, sizeof (buf), "% H:% M:% S% P", & tstruct);' le% P doit être converti en% p (le dernier est standard, le majuscule provoque une assertion dans MSVC 2015).
Fernando Gonzalez Sanchez

3

Ceci a été 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;
}

3

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.


2

Le ffead-cpp fournit plusieurs classes d'utilitaires pour diverses tâches, une de ces classes est la classe Date qui fournit de nombreuses fonctionnalités depuis les opérations Date jusqu'à l'arithmétique des dates, il y a aussi une classe Timer fournie pour les opérations de chronométrage. Vous pouvez voir la même chose.


2

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

Cet intégré semble offrir un ensemble raisonnable d'options.


1
Bien sûr: time_t rawTime; time(&rawTime); struct tm *timeInfo; char buf[80]; timeInfo = localtime(&rawTime); strftime(buf, 80, "%T", timeInfo); Celui-ci met simplement le HH: MM: SS. Mon premier message, donc je ne sais pas comment obtenir le format de code correct. Désolé pour ça.
bduhbya

1

version de localtime_s ():

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

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

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)

}

5
La question demande multiplateforme. Windows.h est spécifique à Windows et void mainn'est même pas C / C ++ standard.
derpface

0

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();
}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.