¿Cómo obtener la hora y fecha actuales en C ++?

457

¿Hay alguna forma multiplataforma para obtener la fecha y hora actuales en C ++?

Max Frai
fuente
2
Si Ockonal todavía está activo, debería cambiar la respuesta aceptada al enfoque de C ++ 11. Esta pregunta todavía parece tener muchas opiniones.
JSQuareD
2
Versión C: stackoverflow.com/questions/1442116/…
Ciro Santilli 郝海东 冠状 病 六四 事件 法轮功
3
@JSQuareD Incluso mirando esta pregunta ahora, después de todo este tiempo, encuentro que el enfoque C es mejor usando la tmestructura. ¿El enfoque de C ++ 11 no solo da la marca de tiempo de Unix (tiempo desde época) aunque la pregunta era acerca de cómo obtener la fecha y la hora?
anddero
¡Wow, esta pregunta tiene 1.110.886 visitas! ¡La gente realmente ama C ++!
Usuario123

Respuestas:

595

En C ++ 11 puedes usar std::chrono::system_clock::now()

Ejemplo (copiado 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";
}

Esto debería imprimir algo como esto:

finished computation at Mon Oct  2 00:59:08 2017
elapsed time: 1.88232s
Federico el tonto
fuente
28
Esto debería ser votado porque es la forma más portátil y fácil en C ++ actual.
Johannes
44
@Johannes, acabo de agregar el mío. A este ritmo, esta debería ser la respuesta principal antes del 15 de agosto de 2017, 16:31 UTC :-)
Martin Broadhurst
6262
Esta respuesta es de muy poca utilidad sin ejemplos de uso del valor obtenido. Por ejemplo, ¿cómo puede imprimirlo, obtener la hora local, comparar con otra fecha / hora?
Steed
32
Esta es la peor respuesta posible. Hace que otras respuestas de c ++ 11 sean duplicadas y, sin embargo, no explica nada, ya que es un 'solo enlace'.
v010dya
10
No hay forma de llegar más al grano que esta respuesta. El OP preguntaba "¿Hay una forma multiplataforma para obtener la fecha y hora actuales en C ++?" Esta pregunta te da exactamente esto. Si tiene dudas sobre cómo obtener un stringarchivo streamo cómo formatearlo correctamente time_point<>, continúe y haga otra pregunta o busque en Google después.
Tarc
482

C ++ comparte sus funciones de fecha / hora con C. La estructura tm es probablemente la más fácil para que trabaje un programador de C ++: lo siguiente imprime la fecha de hoy:

#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";
}
milleniumbug
fuente
26
Úselo ctime()junto con esta respuesta si desea una cadena de fecha.
ralphtheninja
3
¿Qué pasa con la eliminación de la instancia de struct tmes posible simplemente llamar a eliminar en él?
Petr
44
@Petr solo necesita llamar a borrar en la memoria asignada con nuevo.
iheanyi
44
ok pero aun así obtienes un puntero de localtime () para que la instancia de estructura se asigne en el montón o no? lo que significa que no se limpia a menos que lo haga de alguna manera. Nunca dije usar delete(palabra clave c ++), solo pensé que debería eliminarse de alguna manera :) ¿o quién va a hacer eso por usted?
Petr
99
@Petr No es necesario desasignarlo porque está asignado estáticamente, vea aquí este tema stackoverflow.com/questions/8694365/…
Brandin
180

Puede probar el siguiente código multiplataforma para obtener la fecha / hora actual:

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

Salida:

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

Visite aquí para obtener más información sobre el formato de fecha / hora

TrungTN
fuente
Hola. Tengo un pequeño problema con esta asignación "buf" dentro de la función "currentDateTime ()". ¿Cómo se supone que persiste después de que la función ha regresado? Gracias.
Léa Massiot
77
El tipo de retorno es "const std :: string", por lo que se devuelve por valor y luego se realiza una copia del búfer, antes de liberarlo.
barranquero
3
¿Por qué devolver el constvalor? Eso no tiene sentido.
Carreras de ligereza en órbita
¡más 1 para la solución multiplataforma!
Ziagl
139

Las bibliotecas estándar de C proporcionan time(). Esto es segundos de la época y se puede convertir a la fecha y H:M:Susar las funciones estándar de C. Boost también tiene una biblioteca de hora / fecha que puede consultar.

time_t  timev;
time(&timev);
Martin York
fuente
24
La siguiente respuesta de anon tiene una mejor estructura y proporciona un mejor ejemplo.
MDTech.us_MAN
2
Además, preguntó acerca de C ++ no C.
jterm
2
@jterm está bien, C y C ++ comparten exactamente la misma biblioteca de tiempo, es una cuestión de diferentes nombres de importación y eso es todo
Joseph Farah
31

la biblioteca estándar de C ++ no proporciona un tipo de fecha adecuado. C ++ hereda las estructuras y funciones para la manipulación de fecha y hora de C, junto con un par de funciones de entrada y salida de fecha / hora que tienen en cuenta la localización.

// 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;
}
Vaibhav Patle
fuente
25

Nueva respuesta para una vieja pregunta:

La pregunta no especifica en qué zona horaria. Hay dos posibilidades razonables:

  1. En UTC
  2. En la zona horaria local de la computadora.

Para 1, puede usar esta biblioteca de fechas y el siguiente programa:

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

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

Lo que acaba de salir para mí:

2015-08-18 22:08:18.944211

La biblioteca de fechas esencialmente solo agrega un operador de transmisión para std::chrono::system_clock::time_point. También agrega muchas otras funcionalidades agradables, pero eso no se usa en este simple programa.

Si prefiere 2 (la hora local), hay una biblioteca de zonas horarias que se construye sobre la biblioteca de fechas . Ambas bibliotecas son de código abierto y multiplataforma , suponiendo que el compilador sea compatible con C ++ 11 o 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';
}

Lo que para mí acaba de salir:

2015-08-18 18:08:18.944211 EDT

El tipo de resultado de make_zonedes a, date::zoned_timeque es un emparejamiento de ay date::time_zonea std::chrono::system_clock::time_point. Este par representa una hora local, pero también puede representar UTC, dependiendo de cómo lo consulte.

Con la salida anterior, puede ver que mi computadora está actualmente en una zona horaria con un desplazamiento UTC de -4h, y una abreviatura de EDT.

Si se desea alguna otra zona horaria, eso también se puede lograr. Por ejemplo, para encontrar la hora actual en Sydney, Australia, simplemente cambie la construcción de la variable locala:

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

Y la salida cambia a:

2015-08-19 08:08:18.944211 AEST

Actualización para C ++ 20

Esta biblioteca ahora se adopta en gran medida para C ++ 20. El espacio de nombres datese ha ido y todo está en el espacio de nombres std::chronoahora. Y usar zoned_timeen lugar de make_time. Caída de las cabeceras "date.h"y "tz.h"y sólo tiene que utilizar <chrono>.

Mientras escribo esto, las implementaciones parciales apenas comienzan a surgir en algunas plataformas.

Howard Hinnant
fuente
¿No debería localtimedarme el tiempo en mi zona horaria?
Jonathan Mee
Sí, localtimeserá casi siempre le dará el tiempo en su zona horaria local para la segunda precisión. A veces fallará debido a problemas de seguridad de subprocesos, y nunca funcionará para una precisión de un segundo.
Howard Hinnant
19

(Para compañeros de googlers)

También hay 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();
Offirmo
fuente
16
auto time = std::time(nullptr);
std::cout << std::put_time(std::localtime(&time), "%F %T%z"); // ISO 8601 format.

Obtenga la hora actual usando std::time()o std::chrono::system_clock::now()(u otro tipo de reloj ).

std::put_time()(C ++ 11) y strftime()(C) ofrecen muchos formateadores para generar esos tiempos.

#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 secuencia de los formateadores es 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

Los formateadores de strftime()son similares:

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
}

A menudo, el formateador de capital significa "versión completa" y en minúscula significa abreviatura (por ejemplo, Y: 2017, y: 17).


La configuración regional altera la salida:

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

Salida posible ( 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

Lo he usado std::gmtime()para la conversión a UTC. std::localtime()se proporciona para convertir a hora local.

Tenga en cuenta que asctime()/ ctime()que se mencionaron en otras respuestas están marcadas como obsoletas ahora y strftime()deben preferirse.

Roi Danton
fuente
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;
} 
etcheve
fuente
12

Sí, y puede hacerlo con las reglas de formato especificadas por la configuración regional actualmente imbuida:

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

Salida: Fri Sep 6 20:33:31 2013

0x499602D2
fuente
1
Esta es, en mi humilde opinión, la mejor respuesta, ya que es la única que respeta la configuración regional, y porque está programada con tanta atención al detalle (no se ve ostream::sentrytan a menudo).
DevSolar
@DevSolar Gracias. Sin embargo, no diría que es lo mejor. He visto mejores implementaciones. Pero creo que esto es suficiente para un ejemplo :)
0x499602D2
No compiló para mí. Siendo un novato no puedo comentar por qué.
sello histórico
8

podrías usar la clase de tiempo 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;
     }

fuera puesto:

2017-08-25 12:30:08
Sam Abdul
fuente
6

Siempre está la __TIMESTAMP__macro del preprocesador.

#include <iostream>

using namespace std

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

int main() {
    printBuildDateTime();
}

ejemplo: dom abr 13 11:28:08 2014

James Robert Albert
fuente
27
Esto no funcionará ya que TIMESTAMP le dará la hora en que se crea el archivo en lugar de la hora actual.
feelfree
3
Mirando hacia atrás, no tengo idea de por qué me sentí equipado para responder una pregunta de C ++
James Robert Albert
1
__TIMESTAMP__es una macro de preprocesador que se expande a la hora actual (en tiempo de compilación) en la forma Ddd Mmm Date hh :: mm :: ss aaaa. La __TIMESTAMP__macro se puede usar para proporcionar información sobre el momento particular en que se construyó un binario. Consulte: cprogramming.com/reference/preprocessor/__TIMESTAMP__.html
selfboot
4

También puedes usar directamente 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;
} 
Abhishek Gupta
fuente
44
en VS2012, tengo que agregar #define _CRT_SECURE_NO_DEPRECATEantes de incluir para hacer compilaciones de programas
javapowered
4

Este enlace me pareció bastante útil para mi implementación: C ++ Fecha y hora

Aquí está el código que uso en mi implementación, para obtener un formato de salida claro "AAAAMMDD HHMMSS". El parámetro es para cambiar entre la hora UTC y la hora local. Puede modificar fácilmente mi código para satisfacer su necesidad.

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

Salida (UTC, EST):

20161123 000454
20161122 190454
Joe
fuente
¿Por qué preguntaste si ptmNow->tm_day < 9y no <10?
STF
Quiero que un día (digamos el día X) menos de 9 sea 0X (es decir, 1 -> 01, 9 -> 09) para llenar el espacio, para que coincida con nuestro diseño. El día 10 puede ser simplemente 10 en la cadena.
Joe
Por lo tanto, debe preguntar si es <=9porque desea incluir también 9.
STF
Tenga en cuenta que tengo un 1+en el código. Día / mes comienza en 0.
Joe
¡el mes comienza en 0, pero el día comienza en 1!
STF
3

Esto funciona con G ++. No estoy seguro de si esto te ayuda. Salida del programa:

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.

Código:

#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;  
}
Anónimo
fuente
Este es un buen ejemplo, pero la línea 'strftime (buf, sizeof (buf), "% H:% M:% S% P", & tstruct);' debe tener el% P convertido a% p (el último es estándar, el de mayúsculas causa una aserción en MSVC 2015).
Fernando González Sánchez
3

Esto se compiló para mí en Linux (RHEL) y Windows (x64) dirigido a g ++ y 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;
}
Epsilon3
fuente
3

Puede usar el siguiente código para obtener la fecha y hora actuales del sistema 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;
    }

PD: visite este sitio para obtener más información.

Juan
fuente
2

El ffead-CPP ofrece múltiples clases de utilidad para diversas tareas, una de estas clases es la fecha clase que ofrece un montón de características derecha desde operaciones aritméticas de fecha a fecha, también hay un temporizador de la clase prevista operaciones de cronometraje. Puedes echar un vistazo a lo mismo.

usuario775757
fuente
2

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

Este incorporado parece ofrecer un conjunto razonable de opciones.

bduhbya
fuente
1
Claro: time_t rawTime; time(&rawTime); struct tm *timeInfo; char buf[80]; timeInfo = localtime(&rawTime); strftime(buf, 80, "%T", timeInfo); este en particular solo pone el HH: MM: SS. Mi primera publicación, así que no estoy seguro de cómo obtener el formato de código correcto. Lo siento por eso.
bduhbya
1

versión 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;
} 
sailfish009
fuente
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;
}
r3t40
fuente
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)

}
usuario3414278
fuente
55
La pregunta pide multiplataforma. Windows.h es específico de Windows y void mainni siquiera es C / C ++ estándar.
derpface
0

Podrías usar 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();
}
Andreas DM
fuente