Unable to create a folder with todays date in c++ - c++

Im trying to create a folder with todays date in c++. WHile in python its very easy , in c++ im finding it challenging.
I tried this code where first I tried to print the date and then use the date values to create a folder. I even tried inserting unix commands but even those didnt work.
I simply want to create a directory like : DD_MM_YYYY or DD_MM_YY
#include <bits/stdc++.h>
#include <iostream>
#include <sys/stat.h>
#include <sys/types.h>
#include "time.h"
//#include "date/tz.h"
using namespace std;
using namespace std::chrono;
int main()
{ //option 1
time_t my_time =time(NULL);
cout << ctime(&my_time)<<endl;
///option 2
time_t t = time(NULL);
struct tm tm = *localtime(&t);
printf("now: %d-%d-%d %d:%d:%d\n", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
printf("Date: %d_%d_%d\n", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
// EXPERIMENT SECTION : ALL OF THESE THROWING ERRORS
//sub_fol=(tm.tm_year+1900).ToString()+"."+tm.tm_mon.ToString();
//sub_fol=tm.tm_mon;
string str="date +'%d_%m_%y'";
//str="mkdir "+ str;
const char *command=str.c_str();
//string dr=system(command);
//printf(string(tm.tm_mon));
// THIS ONES WORKING
if (mkdir("test_", 0777) == -1)
cerr << "Error : " << strerror(errno) << endl;
else
cout << "Directory created";
// THIS ONE ISNT WORKING
if (mkdir(system(command), 0777) == -1)
cerr << "Error : " << strerror(errno) << endl;
else
cout << "Directory created";
}

You can make use of std::localtime and std::puttime to get a formatted date.
For example:
#include <iostream>
#include <chrono>
#include <sstream>
#include <iomanip>
int main()
{
auto const now = std::chrono::system_clock::now();
auto const in_time_t = std::chrono::system_clock::to_time_t(now);
std::stringstream ss;
ss << std::put_time(std::localtime(&in_time_t), "%d_%m_%Y");
std::cout << ss.str() << std::endl;
}
Will get you:
14_01_2021
You can see https://en.cppreference.com/w/cpp/io/manip/put_time for more formatting options.
Then you can use mkdir or make use of std::filesystem if you are using C++17 or above.
#include <filesystem>
...
std::filesystem::create_directory("abc");
See https://en.cppreference.com/w/cpp/filesystem/create_directory
For mkdir it expects a const char *path rather than a std::string but you can get a char pointer via c_str() e.g.:
mkdir(ss.str().c_str(), 0700);

Related

convert time string to epoch in milliseconds using C++

I try to convert the following time string to epoch in milliseconds
"2022-09-25T10:07:41.000Z"
i tried the following code which outputs only epoch time in seconds (1661422061) how to get the epoch time in milliseconds.
#include <iostream>
#include <sstream>
#include <locale>
#include <iomanip>
#include <string>
int main()
{
int tt;
std::tm t = {};
std::string timestamp = "2022-09-25T10:07:41.000Z";
std::istringstream ss(timestamp);
if (ss >> std::get_time(&t, "%Y-%m-%dT%H:%M:%S.000Z"))
{
tt = std::mktime(&t);
std::cout << std::put_time(&t, "%c") << "\n"
<< tt << "\n";
}
else
{
std::cout << "Parse failed\n";
}
return 0;
}
You can use the C++20 features std::chrono::parse / std::chrono::from_stream and set the timepoint to be in milliseconds.
A modified example from my error report on MSVC on this subject which uses from_stream:
#include <chrono>
#include <iostream>
#include <locale>
#include <sstream>
int main() {
std::setlocale(LC_ALL, "C");
std::istringstream stream("2022-09-25T10:07:41.123456Z");
std::chrono::sys_time<std::chrono::milliseconds> tTimePoint;
std::chrono::from_stream(stream, "%Y-%m-%dT%H:%M:%S%Z", tTimePoint);
std::cout << tTimePoint << '\n';
auto since_epoch = tTimePoint.time_since_epoch();
std::cout << since_epoch << '\n'; // 1664100461123ms
// or as 1664100461.123s
std::chrono::duration<double> fsince_epoch = since_epoch;
std::cout << std::fixed << std::setprecision(3) << fsince_epoch << '\n';
}
Demo
If you are stuck with C++11 - C++17 you can install the date library by Howard Hinnant. It's the base of what got included in C++20 so if you upgrade to C++20 later, you will not have many issues.
#include "date/date.h"
#include <chrono>
#include <iostream>
#include <sstream>
int main() {
std::istringstream stream("2022-09-25T10:07:41.123456Z");
date::sys_time<std::chrono::milliseconds> tTimePoint;
date::from_stream(stream, "%Y-%m-%dT%H:%M:%S%Z", tTimePoint);
auto since_epoch = tTimePoint.time_since_epoch();
// GMT: Sunday 25 September 2022 10:07:41.123
std::cout << since_epoch.count() << '\n'; // prints 1664100461123
}

C++ values from struct creating newlines in CSV file

I am very new to C++, and currently am attempting to create a simple user interface which will do the following:
Check if a CSV file already exists with the given name
Create that file if it does not exists, and write the headers
Ask user for information, store in struct
Write data to CSV file when done
The issue I am facing is that when the program ends, and writes the data to the CSV file it creates newlines for each struct variable I am writing. I would like the program to just write all data on one line with comma separated format.
Example code:
struct.h
#ifndef struct_h
#define struct_h
#include "string"
namespace RB
{
struct Values
{
std::string event;
std::string town;
std::string state;
std::string date;
};
}; // namespace
#endif /* struct_h */
create.h
#ifndef create_h
#define create_h
#include <cstdio>
#include <ctime>
#include <iostream>
#include <fstream>
namespace RB
{
int createFile()
{
time_t t = time(nullptr); // the current time
struct tm gmt = *gmtime(&t); // structured time in GMT
const int year = 1900 + gmt.tm_year;
static const char *filename = "results_";
if (std::ifstream((filename + std::to_string(year) + ".csv").c_str()))
{
std::cout << "File Found, appending to file " << (filename + std::to_string(year) + ".csv").c_str() << std::endl;
}
else
{
std::cout << "No file with name " << (filename + std::to_string(year) + ".csv").c_str() << "\ncreating file...\n" << std::endl;
std::ofstream ofile((filename + std::to_string(year) + ".csv").c_str());
ofile << "Event" << ","
<< "Town" << ","
<< "State" << ","
<< "Date" << "\n";
ofile.flush();
ofile.close();
};
return 0;
};
}
#endif /* create_h */
main.cpp
#include <cstdio>
#include <stdlib.h>
#include <iostream>
#include "struct.h"
#include "create.h"
int main()
{
// Run Create before continuing
int c = RB::createFile();
struct RB::Values revent;
// Get Event Name
std::cout << "Starting to enter data for race event...\n" << std::endl;
std::cout << "What was the name of the event: ";
std::cin >> revent.event;
// Get Event Town
std::cout << "What town was the race run in: ";
std::cin >> revent.town;
// Get Event City
std::cout << "What state was the race run in: ";
std::cin >> revent.state;
// Get Event Date
std::cout << "When was the race run: ";
std::cin >> revent.date;
time_t t = time(nullptr); // the current time
struct tm gmt = *gmtime(&t); // structured time in GMT
const int year = 1900 + gmt.tm_year;
static const char *filename = "results_";
if (std::ifstream((filename + std::to_string(year) + ".csv").c_str()))
{
std::ofstream ofile((filename + std::to_string(year) + ".csv").c_str(), std::ofstream::out | std::ofstream::app);
ofile << revent.event << ",";
ofile << revent.town << ",";
ofile << revent.state << ",";
ofile << revent.date;
ofile.close();
};
return 0;
}
Sample Output:
Event,Town,State,Date
CapRock
,Turkey
,Texas
,March 9
I assume this is something simple I am doing wrong, but cannot seem to figure it out on my own.

Error checking for empty directory in C++

I'm trying to create a folder named by todays date (on Ubuntu) and then check if it's empty or not.
The empty-or-not check will be done several times daily.
#include <cstdlib>
#include <unistd.h>
#include <stdio.h>
#include <iostream>
#include <typeinfo>
#include <chrono>
#include <time.h>
#include <iomanip>
using namespace std;
int main() {
//Pull out system date and create a folder named by system date
auto const now = std::chrono::system_clock::now();
auto const in_time_t = std::chrono::system_clock::to_time_t(now);
std::stringstream ss;
ss << std::put_time(std::localtime(&in_time_t), "%d_%m_%Y");
// Creating todays date folder with entry folder
string str_2=std::string("mkdir -p " + string(ss.str()) + "/entry");
const char *com2=str_2.c_str();
system(com2);
//check if directory is empty or not
int check;
char is_empty[100];
FILE * output;
output = popen("ls " + ss.str() + "/entry | wc -l","r") ;
fgets (is_empty, 100, output); //write to the char
pclose (output);
check = atoi(is_empty);
if (check == 0) {
cout << "The folder is empty" << endl;
}
}
I'm getting this error when compiling this code:
error: no match for ‘operator+’ (operand types are ‘const char [4]’
and ‘std::stringstream {aka std::__cxx11::basic_stringstream<char>}’)
output = popen("ls " +ss+ "/entry | wc -l","r") ;
This solved it for me
int check;
char is_empty[100];
FILE * output;
string cmd = std::string("ls " + string(ss.str())+ "/entry | wc -l") ;
const char *com4 = cmd.c_str();
output = popen(com4,"r");
fgets(is_empty, 100, output);
pclose (output);
check = atoi(is_empty);
//cout << check<<endl;
if (check == 0){
cout << "The folder is empty" << endl;
}

Date and Time with high precision in Windows using C++

I am new to C++ programming in Windows environment.
I want to get the current system date and time in the below format:
DD-MM-YYYY HH:MM:SS.Milliseconds using Windows C++ API.I need to capture is up to microseconds. Could you please share a sample code on how to achieve this in Windows.
Using the draft C++20 spec:
#include <chrono>
#include <iostream>
int
main()
{
using namespace std;
using namespace std::chrono;
cout << format("%d-%m-%Y %T", floor<microseconds>(system_clock::now())) << '\n';
}
Currently VS does not implement this, but you can get a preview by using Howard Hinnant's date/time library. Just include it and add a using directive:
#include "date/date.h"
#include <chrono>
#include <iostream>
int
main()
{
using namespace date;
using namespace std;
using namespace std::chrono;
cout << format("%d-%m-%Y %T", floor<microseconds>(system_clock::now())) << '\n';
}
As you asked for "system time", this delivers a UTC time stamp, as that is what your system time measures. If you instead want local time, that is also available, but requires some installation.
Sample output:
29-11-2018 14:45:03.679098
I recommend to use std::chrono library. Look at this example:
#include <chrono>
#include <ctime>
#include <sstream>
#include <iomanip>
#include <string>
std::string current_datetime()
{
using namespace std::chrono;
// get current time
auto now = high_resolution_clock::now();
// get duration in milliseconds
auto msec = duration_cast<milliseconds>(now.time_since_epoch()).count();
msec %= 1000;
// get printable result:
auto now_time_t = high_resolution_clock::to_time_t(now);
std::stringstream ss;
ss << std::put_time(std::gmtime(&now_time_t), "%d-%m-%Y %X:") << msec;
return ss.str();
}
int main()
{
for(auto i = 0U;i < 1000;i++)
std::cout << current_datetime() << std::endl;
}
Also it's possible to get microseconds:
auto mksec = duration_cast<microseconds>(now.time_since_epoch()).count();
mksec %= 1000;
If you need WinAPI-specific version that's it:
std::string current_datetime2()
{
FILETIME ft;
GetSystemTimeAsFileTime(&ft);
unsigned long long mks = static_cast<unsigned long long>(ft.dwHighDateTime) << 32 | ft.dwLowDateTime;
mks /= 10; // interval in microsecond
mks %= 1000;
SYSTEMTIME st;
FileTimeToSystemTime(&ft, &st);
std::stringstream ss;
ss << st.wDay << "-" << st.wMonth << "-" << st.wYear << " " <<
st.wHour << ":" << st.wMinute << ":" << st.wSecond << ":" << st.wMilliseconds << ":" << mks << std::endl;
return ss.str();
}
or another very simple WinAPI-version, but without microseconds:
std::string current_datetime3()
{
SYSTEMTIME st;
GetSystemTime(&st);
std::stringstream ss;
ss << st.wDay << "-" << st.wMonth << "-" << st.wYear << " " <<
st.wHour << ":" << st.wMinute << ":" << st.wSecond << ":" << st.wMilliseconds;
return ss.str();
}
on windows platform:
SYSTEMTIME st;
GetLocalTime(&st);
TCHAR buf[128];
_stprintf_s(buf, _ARRAYSIZE(buf),
_T("%04u-%02u%-%02u %02u:%02u:%02u.%03u"),
st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
will fulfill most cases. If you want to get more accurate timespan, use
QueryPerformanceFrequency,
QueryPerformanceCounter;

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

Is there a cross-platform way to get the current date and time in C++?
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
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";
}
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
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);
New answer for an old question:
The question does not specify in what timezone. There are two reasonable possibilities:
In UTC.
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.
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.
(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();
#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 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
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
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
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.
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 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
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;
}
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;
}
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.
http://www.cplusplus.com/reference/ctime/strftime/
This built-in seems to offer a reasonable set of options.
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;
}
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 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)));
}
#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)
}
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";
}