How to get current time and date in C++?

Question

Is there a cross-platform way to get the current date and time in C++?

Changeling

If Ockonal is still active, he should change the accepted answer to the C++11 approach. This question still seems to get a lot of views. – Sahara

C version: stackoverflow.com/questions/1442116/… – Aleece

@Sahara Even looking at this question now after all this time, I find the C approach better using the tm structure. Doesn't the C++11 approach just give the unix timestamp (time since epoch) although the question was about getting the date and time? – Peneus

Wow, this question has 1,110,886 views! People really love C++! – Nummary

No, they just hate ::std::chrono. It's indecipherable gibberish. – Casaleggio

Answer 1

Since C++ 11 you can use std::chrono::system_clock::now()

Example (copied from 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"
              << std::endl;
}

This should print something like this:

finished computation at Mon Oct  2 00:59:08 2017
elapsed time: 1.88232s

Farnham

This should be upvoted because it's the most portable and easy way in current C++. – Samuelson

@Johannes, just added mine. At this rate, this should be the top answer by 15 August 2017, 16:31 UTC :-) – Emmanuel

This answer is of very little use without examples of using the obtained value. E.g. how can you print it, get local time, compare with other date/time? – Underact

Examples exist at the linked page. – Farnham

how to change the result of std::chrono::system_clock::now() to string? not cout – Paranoid

This is the worst answer possible. It makes other c++11 answers a duplicate, and yet it explains nothing, being a 'link only'. – Smashed

There's no way to get more to the point than this answer. The OP was asking "Is there a cross-platform way to get the current date and time in C++?" This question gives you exactly this. If you are in doubt about how to get a string from stream, or how to properly format a time_point<>, go ahead and ask another question or google after it. – Quartas

I tried using ctime(&end_time) like this and get the following compile error: error C4996: 'ctime': This function or variable may be unsafe. Consider using ctime_s instead. Is it standard practice to use ctime_s for compiling on Windows? – Soapy

Why isn't there some simple function I can call, which would capture the current local time, with member functions giving me access to all components found in struct tm and some other string conversion functions. All these calls to get basic, common information and add 1900 here, 1 there. Seems absurd. – Elmiraelmo

@Elmiraelmo Welcome to C++ – Farnham

This doesn't get you the current time... it gets a duration between two times... How do you just print what the current time is? – Chronometer

@Chronometer The first line - "finished computation at" - is the current time. now() gives the current time (as a time_point: en.cppreference.com/w/cpp/chrono/time_point) – Keratinize

Answer 2

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 time now
    std::tm* now = std::localtime(&t);
    std::cout << (now->tm_year + 1900) << '-' 
         << (now->tm_mon + 1) << '-'
         <<  now->tm_mday
         << "\n";
}

Stupefy

Use ctime() together with this answer if you want a date string. – Grati

what about deleting the instance of struct tm is it possible to just call delete on it? – Dogear

@Dogear you only need to call delete on memory allocated with new. – Tramway

ok but still you get a pointer from localtime() so the structure instance gets allocated on heap or not? which means it doesn't get cleaned unless you do that somehow. I never said use delete (c++ keyword) on it, I just thought it should be deleted somehow :) or who is going to do that for you? – Dogear

@Dogear You don't need to deallocate it because it is allocated statically, see here for this topic stackoverflow.com/questions/8694365/… – Hounding

Question: Is there a reason to have the variable 'now' be a pointer? Why not just say: struct tm now =* localtime( & t ); – Burweed

@Hard.Core.Coder: Why make an unnecessary copy? – Sonneteer

why need to add 1900 for year and add 1 to month? – Johnathan

@Johnathan Because tm_year counts from 1900 and tm_mon has the range [0, 11] by definition. E.g. see the link in the answer. – Orvieto

One more question - how to do the same for milliseconds? – Hebrew

std::time_t t = std::time(0) is not UTC nor locale... it is epoch (so totally universal). OK, you could say epoch is UTC0, well, yes. So why std::gmtime(t) produces wrong UTC time? Is is not really UTC? – Nf

Why do you have the + 1900? (this is not a rhetorical question, I want to learn) – Alodee

Use localtime_s instead for thread-safe reason – Unweave

As I can't Edit this answer (due to the stupid "Suggested edit que is full" reason), the output of the above program is "today's date" e.g. 2022-9-2. It doesn't output time! – Submerse

When I run this my timestamp looks like this: apISt4pairI5UnitsS4_EdSt4lessIS5_ESaIS3_IKS5_dEEEEEE – Forgetful

Answer 3

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

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

Output:

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

Please visit here for more information about date/time format

Heshum

Hello. I have a little problem with this "buf" allocation inside the function "currentDateTime()". How is it supposed to persist after the function has returned? Thx. – Orthognathous

The return type is "const std::string", so it is returned by value and then a copy of buffer is made, before releasing it. – Vitals

Why return const value? That's purposeless. – Dall

plus 1 for cross-platform solution! – Badmouth

Nowadays localtime is deprecated in favor of localtime_s with a syntax varying among different C implementations. Microsoft's flavor reads: errno_t err = localtime_s(&tstruct, &now); – Deiform

Answer 4

std C libraries provide time(). This is seconds from the epoch and can be converted to 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);

Syllabary

anon's answer below has a better structure and provides a better example. – Penstock

Also, he asked about C++ not C. – Ducat

@Ducat its ok, C and C++ share the exact same time library, its a matter of different import names and thats it – Daggett

Answer 5

New answer for an old question:

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

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 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 -4h, 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

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

Et

Shouldn't localtime give me the time in my timezone? – Partlow

Yes, localtime will nearly always give you the time in your local timezone to second precision. Sometimes it will fail because of threadsafety issues, and it will never work for subsecond precision. – Et

would be cool if you could also provide the update for UTC. Because the obvious std::cout << std::chrono::system_clock::now(); fails – Foreplay

The obvious should work. Perhaps it hasn't been implemented by your std::lib vendor yet? eel.is/c++draft/… – Et

I tried this with gnu++20 and here is the error: "error: ‘zoned_time’ was not declared in this scope" – Vieira

Here is the status of gcc implementing C++20 library features: gcc.gnu.org/onlinedocs/libstdc++/manual/… – Et

Answer 6

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

Myriammyriameter

Answer 7

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.

Orvieto

std::put_time() doesn't work with the output of std::chrono::system_clock::now(). – Babur

You can use std::chrono::system_clock::to_time_t() to convert the output of the system clock. – Orvieto

Answer 8

(For fellow googlers)

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

Berberidaceous

Answer 9

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

Lumbricoid

Answer 10

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

Paring

This is, IMHO, actually the best answer, since it is the only one that honors locale settings, and because it is programmed with such attention to detail (you don't see ostream::sentry that often). – Zany

@Zany Thanks. I wouldn't say it's the best though. I've seen better implementations. But I think this suffices for an example :) – Paring

Didn't compile for me. Being a novice I cannot comment on why. – Psi

Answer 11

you could use 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;
     }

out put:

2017-08-25 12:30:08

Copybook

Answer 12

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

Thumb

This will not work as TIMESTAMP will give the time when the file is created rather than the current time. – Clarkin

looking back at this, I have no idea why I felt equipped to answer a C++ question – Thumb

__TIMESTAMP__ is a preprocessor macro that expands to current time (at compile time) in the form Ddd Mmm Date hh::mm::ss yyyy. The __TIMESTAMP__ macro can be used to provide information about the particular moment a binary was built. Refer: cprogramming.com/reference/preprocessor/__TIMESTAMP__.html – Jankell

Answer 13

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

Latisha

C4996 'ctime': This function or variable may be unsafe. Consider using ctime_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. – Lycia

Answer 14

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() {
       // 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: Visit this site for more information.

Dickerson

Answer 15

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

Supranational

in VS2012 i have to add #define _CRT_SECURE_NO_DEPRECATE before include to make program compiles – Bronchial

Answer 16

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 param in is for switching between UTC and local time. You can easily modify my code to suite your need.

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

Output (UTC, EST):

20161123 000454
20161122 190454

Edda

Why did you ask if the ptmNow->tm_day < 9 and not <10? – Sitzmark

I want a day (say day X) less than 9 to be 0X (i.e. 1 -> 01, 9 -> 09) to fill up the space, in order to match our design. Day 10 can simply be 10 in the string. – Edda

So you need to ask if it's <=9 because you want to include also 9. – Sitzmark

Note I have a 1+ in the code. Day/Month starts at 0. – Edda

month start at 0, but day start at 1! – Sitzmark

Yes you are correct. Then just change <9 to <=9 or <10, and remove the +1 at day. – Edda

Answer 17

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

Inclination

This is the best answer. It integrates formatting and does not show unsafe errors or buffer overrun warnings like others. – Quemoy

@Gru: Thanks, yeah, I'm not a fan of old school code full of warnings by state of the art IDEs and code analyzers lol – Inclination

Answer 18

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

Jacquelinejacquelyn

This is a good example, but the line 'strftime(buf, sizeof(buf), "%H:%M:%S %P", &tstruct);' must have the %P converted to %p (the latest one is standard, the upper case one causes an assertion in MSVC 2015). – Kidder

Answer 19

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

Covington

Answer 20

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.

Finstad

Answer 21

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

This built-in seems to offer a reasonable set of options.

Enunciation

Sure: time_t rawTime; time(&rawTime); struct tm *timeInfo; char buf[80]; timeInfo = localtime(&rawTime); strftime(buf, 80, "%T", timeInfo); This particular one just puts the HH:MM:SS. My first post so I m not sure how to get the code format correct. Sorry about that. – Enunciation

Answer 22

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

Leisurely

Answer 23

You could use boost and 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)));
}

Brassie

Answer 24

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

Boren

Answer 25

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

}

Ribaldry

The question asks for cross-platform. Windows.h is Windows-specific, and void main isn't even standard C/C++. – Pachston

Answer 26

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

Teuton

As it’s currently written, your answer is unclear. Please edit to add additional details that will help others understand how this addresses the question asked. You can find more information on how to write good answers in the help center. – Dewyeyed

Answer 27

I needed a way to insert current date-time at every update of a list. This seems to work well, simply.

#include<bits/stdc++.h>
#include<unistd.h>
using namespace std;
int main()
{   //initialize variables
    time_t now; 
    //blah..blah
    /*each time I want the updated stamp*/
    now=time(0);cout<<ctime(&now)<<"blah_blah";
}

Dorm

There are already a lot of answers on this question, including ones showing how to use time(), so this answer doesn't add anything new. – Unnatural

@Unnatural That and #include <bits/stdc++.h is a HUGE no-no – Boothe