C++ shares its date/time functions with C. The tm structure is probably the easiest for a C++ programmer to work with. The following prints today's date:

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

You can try the following cross-platform code to get the current date/time:

#include <iostream> #include <string> #include <stdio.h> #include <time.h> // Get the current date/time. The 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 the 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 } 

Output:

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

Please visit here for more information about the date/time format.

Standard C libraries provide time().

This is seconds from the epoch and can be converted to a date and H:M:S using standard C functions. Boost also has a time/date library that you can check.

time_t timev; time(&timev); 

The question does not specify in what timezone. There are two reasonable possibilities:

1. In UTC.
2. In the computer's local timezone.

For 1, you can use this date library and the following program:

#include "date.h" #include <iostream> int main() { using namespace date; using namespace std::chrono; std::cout << system_clock::now() << '\n'; } 

Which just outputs for me:

2015-08-18 22:08:18.944211 

The date library essentially just adds a streaming operator for std::chrono::system_clock::time_point. It also adds a lot of other nice functionality, but that is not used in this simple program.

If you prefer 2 (the local time), there is a timezone library that builds on top of the date library. Both of these libraries are open source and cross platform, assuming the compiler supports C++11 or 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'; } 

Which for me just outputs:

2015-08-18 18:08:18.944211 EDT 

The result type from make_zoned is a date::zoned_time which is a pairing of a date::time_zone and a std::chrono::system_clock::time_point. This pair represents a local time, but it can also represent UTC, depending on how you query it.

With the above output, you can see that my computer is currently in a timezone with a UTC offset of -4 hours, and an abbreviation of EDT.

If some other timezone is desired, that can also be accomplished. For example, to find the current time in Sydney, Australia, just change the construction of the variable local to:

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

And the output changes to:

2015-08-19 08:08:18.944211 AEST 

For C++20

This library is now largely adopted for C++20. The namespace date is gone, and everything is in namespace std::chrono now. And use zoned_time in place of make_time. Drop the headers "date.h" and "tz.h" and just use <chrono>.

#include <chrono> #include <iostream> int main() { using namespace std::chrono; auto local = zoned_time{current_zone(), system_clock::now()}; std::cout << local << '\n'; // 2021-05-03 15:02:44.130182 EDT } 

As I write this, partial implementations are just beginning to emerge on some platforms.

The C++ standard library does not provide a proper date type. C++ inherits the structs and functions for date and time manipulation from C, along with a couple of date/time input and output functions that take into account localization.

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

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

Get the current time either using std::time() or std::chrono::system_clock::now() (or another clock type).

std::put_time() (C++11) and strftime() (C) offer a lot of formatters to output those times.

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

The sequence of the formatters matters:

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 

The formatters of strftime() are similar:

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 } 

Often, the capital formatter means "full version" and lowercase means abbreviation (e.g. Y: 2017, y: 17).

Locale settings alter the output:

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

Possible output (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 

I've used std::gmtime() for conversion to UTC. std::localtime() is provided to convert to local time.

Heed that asctime()/ctime() which were mentioned in other answers are marked as deprecated now and strftime() should be preferred.

There is also 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; } 

Yes and you can do so with formatting rules specified by the currently-imbued locale:

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

Output: Fri Sep 6 20:33:31 2013

You could use the C++11 time class:

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

Output:

2017-08-25 12:30:08 

std::ctime

Why was ctime only mentioned in the comments so far?

#include <ctime> #include <iostream> int main() { std::time_t result = std::time(nullptr); std::cout << std::ctime(&result); } 

Output

Tue Dec 27 17:21:29 2011

There's always the __TIMESTAMP__ preprocessor macro.

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

Example: Sun Apr 13 11:28:08 2014

You can use the following code to get the current system date and time in 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() { // The current date/time based on the 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: Visit this site for more information.

Here is the non-deprecated modern C++ solution for getting a timestamp as a std::string for use with e.g. filenames:

std::string get_file_timestamp() { const auto now = std::chrono::system_clock::now(); const auto in_time_t = std::chrono::system_clock::to_time_t(now); std::stringstream output_stream; struct tm time_info; const auto errno_value = localtime_s(&time_info, &in_time_t); if(errno_value != 0) { throw std::runtime_error("localtime_s() failed: " + std::to_string(errno_value)); } output_stream << std::put_time(&time_info, "%Y-%m-%d.%H_%M_%S"); return output_stream.str(); } 

You can also directly use 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; } 

I found this link pretty useful for my implementation: C++ Date and Time

Here's the code I use in my implementation, to get a clear "YYYYMMDD HHMMSS" output format. The parameter in is for switching between UTC and local time. You can easily modify my code to suit your needs.

#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; // Minutes if (ptmNow->tm_min < 10) currentDateTime << "0" << ptmNow->tm_min; else currentDateTime << ptmNow->tm_min; // Seconds if (ptmNow->tm_sec < 10) currentDateTime << "0" << ptmNow->tm_sec; else currentDateTime << ptmNow->tm_sec; return currentDateTime.str(); } 

Output (UTC, EST):

20161123 000454 20161122 190454 

This works with G++. I'm not sure if this helps you.

Program output:

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 the 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 << "The day of the month is " << (now->tm_mday) << "and the month of the year is " << (now->tm_mon)+1 << "," << endl; cout << "Also, the day of year is " << (now->tm_yday) << "and our weekday is " << (now->tm_wday) << "." << endl; cout << "The current year is " << (now->tm_year) + 1900 << "." << endl; return 0; } 

This compiled for me on Linux (RHEL) and Windows (x64) targeting g++ and 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; } 

localtime_s() version:

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

The ffead-cpp provides multiple utility classes for various tasks. One such class is the Date class which provides a lot of features right from Date operations to date arithmetic. There's also a Timer class provided for timing operations. You can have a look at the same.

The built-in function strftime() seems to offer a reasonable set of options.

You could use Boost and the chrono library:

#include <iostream> #include <chrono> #include <boost/date_time/posix_time/posix_time.hpp> using boost::posix_time::to_iso_extended_string; using boost::posix_time::from_time_t; using std::chrono::system_clock; int main() { auto now = system_clock::now(); std::cout << to_iso_extended_string(from_time_t(system_clock::to_time_t(now))); } 

#include<iostream> #include<iomanip> using namespace std; int main() { time_t currentTime = time(NULL); tm localTime; localtime_s(&localTime, &currentTime); int currentM = localTime.tm_mon + 1; int currentY = localTime.tm_year +1900; int currentD = localTime.tm_mday; // Display the current year, month, and day cout << "Current Year: " << currentYear << endl; cout << "Current Month: " << currentMonth << endl; cout << "Current Day: " << currentDay << endl; return 0; } 

#include <Windows.h> void main() { // The 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) }