pedir - obtener fecha del sistema en dev c++

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

Question

¿Existe una forma multiplataforma para obtener la fecha y hora actuales en C ++?

Answer 1

(Para los compañeros de Google)

También está 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();

Answer 2

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

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

Answer 3

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

Answer 4

Encontré este enlace bastante útil para mi implementación: C ++ Fecha y hora

Aquí está el código que utilizo en mi implementación, para obtener un claro formato de salida "YYYYMMDD 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

Answer 5

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

Answer 6

Esto lo compilé en Linux (RHEL) y Windows (x64) para 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;
}

Answer 7

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

Answer 8

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 del ordenador.

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 no se usa en este programa simple.

Si prefieres 2 (la hora local), hay una biblioteca de zona horaria que se basa en la biblioteca de fechas . Ambas bibliotecas son de código abierto y multiplataforma , asumiendo que el compilador admite 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'';
}

Que para mi acaba de salir:

2015-08-18 18:08:18.944211 EDT

El tipo de resultado de make_zoned es una date::zoned_time que es un emparejamiento de una date::time_zone y un 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 local a:

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

Y la salida cambia a:

2015-08-19 08:08:18.944211 AEST

Answer 9

Podría 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();
}

Answer 10

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

Answer 11

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 here para obtener más información sobre el formato de fecha / hora

Answer 12

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: visita este sitio para más información.

Answer 13

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

Answer 14

Siempre __TIMESTAMP__ macro del preprocesador __TIMESTAMP__ .

#include <iostream>
using namespace std
void printBuildDateTime () {
cout << __TIMESTAMP__ << endl;
}
int main() {
printBuildDateTime();
}

Ejemplo: dom 13 de abril 11:28:08 2014

Answer 15

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

Answer 16

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

time_t timev;
time(&timev);

Answer 17

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

Answer 18

ffead-cpp proporciona varias clases de utilidades para diversas tareas, una clase de este tipo es la clase de Date que proporciona muchas características desde las operaciones de fecha hasta la aritmética de fecha, también hay una clase de temporizador para las operaciones de tiempo. Puedes echar un vistazo a lo mismo.

Answer 19

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

Este incorporado parece ofrecer un conjunto razonable de opciones.

Answer 20

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

Answer 21

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

Answer 22

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

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

std::put_time() (C ++ 11) y here (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 importa:

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

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

Preste atención a que asctime() / ctime() que se mencionaron en otras respuestas están marcados como obsoletos ahora y debe preferirse strftime() .