I want to implement Unix milliseconds converter to human readable date format.
using this post https://stackoverflow.com/a/1657307/1979882 I found I can receive such string but I can't setup a time zone inside the code. The code uses only system time zone.
#include <stdio.h>
#include <time.h>
int main ( int argc, char *argv[] )
{
time_t now;
struct tm *lcltime;
now = time ( NULL );
lcltime = localtime ( &now );
printf ( "The time is %d:%d\n", lcltime->tm_hour, lcltime->tm_min );
return 0;
}
Is it possible to customize it?
EDIT
I need some Java-like method:
SimpleDateFormat df= new SimpleDateFormat("dd MMM hh:mm z",Locale.ENGLISH);
df.setTimeZone("Europe/London");
System.out.println("London Time " + df.format(System.currentTime()));
df.setTimeZone("Asia/Benjin");
System.out.println("Benjin Time " + df.format(System.currentTime()));
EDIT_2
I found I can setup time zone using setenv(...)
url
https://stackoverflow.com/a/1620451/1979882
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main (int argc, char *argv[])
{
struct tm *mt;
time_t mtt;
char ftime[10];
setenv("TZ", "PST8PDT", 1);
tzset();
mtt = time(NULL);
mt = localtime(&mtt);
strftime(ftime,sizeof(ftime),"%Z %H%M",mt);
printf("%s\n", ftime);
}
But in changes the system time zone. I need just time zone modification only inside my code.
You can change the argument to localtime based on the timezone difference required.
now += (time_t)(3600*TIME_DIFF_IN_HRS)
lcltime = localtime ( &now );
To be totally portable, you can get the current time zone by referring this post
Related
i need to convet current time in milliseconds to human readable time format. I have following code
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <sys/time.h>
#include <time.h>
int Cnvrt_To_Time_Frmt(char *Epochval)
{
unsigned long epoch = 0;
time_t tt = 0;
char timestamp[64],usec_buf[20];
if (!sscanf(Epochval, "%lu", &epoch))
{
return 1;
}
tt = epoch;
strftime(timestamp, 64, "%c", localtime(&tt));
printf("%s\n",timestamp);
return 0;
}
int main()
{
uint64_t Epoch_time=1468496250207;
char str_ms[256];
sprintf(str_ms, "%llu", (Epoch_time/1000));
Cnvrt_To_Time_Frmt(str_ms);
}
It produce result : Thu Jul 14 17:07:30 2016.
But i need to print result with milli seconds. like Thu Jul 14 17:07:30:40 2016.(17 hour,07 minute, 30 second, 40 milliSecond)
How it will be possible?
Type time_t by its definition doesn't represent time with milliseconds resolution, function localtime returns pointer to struct tm which does not include milliseconds, function strftime is not designed to produce strings with milliseconds.
If you need time with milliseconds you can use timeb stucture with its associated ftime function if those are supported by your tool-chain.
Use this as format string:
strftime(timestamp, 64, "%a %b %d %H:%M:%S.XXX %Y", localtime(&tt));
The XXX will be copied as-is into the time string.
Then in main, you can overwrite the Xs with the millisecond count.
sprintf(×tamp[20], "%03u", (unsigned)Epoch_time%1000);
timestamp[23] = ' '; // restore the NUL to space again
After that, refactor your code so the divisions and remainder operations are done inside Cnvrt_To_Time_Frmt. You could use this as prototype:
int msecs_tostr(char *buffer, const char *msecs_since_epoch);
I don't have 50 reps yet so I can't comment so I will write my suggestion as an answer here.
You can use the other guys suggestions they are pretty good or you can make your own struct and a function that converts the mili seconds into time , by using basic math functions.
Make a struct that contains dayOfWeek , month , dayOfMonth , hour, minute, second , milliSecond , year.
Make a convertFunction that will receive a value of milliSeconds that need to be converted to your struct format.
Maybe its not the best way to do it , but if you don't find a way of using existing libraries , make your own .
... need to print result with milli seconds. ... How it will be possible?
Take it step by step
uint64_t Epoch_time=1468496250207;
// Break time into a whole number of seconds and ms fraction
time_t t_unix = Epoch_time/1000;
unsigned t_ms = Epoch_time%1000;
// Convert to YMD HMS structure
struct tm tm = *localtime(&t_unix);
// Form left portion of string
char left[64];
strftime(left, sizeof left, "%a %b %d %H:%M", &tm);
// Form right portion of string
char right[20];
strftime(right, sizeof right, "%Y", &tm);
// Put together with ms
char timestamp[64];
snprintf(timestamp, sizeof timestamp, "%s:%u %s", left, t_ms, right);
// Thu Jul 14 17:07:30:40 2016
// Print as needed
puts(timestamp);
Robust code would add error checking with each function's return value.
[edit]
Evidently OP's time stamp's last 3 digits are a fraction / 512.
unsigned t_fraction = Epoch_time%1000;
...
snprintf(timestamp, sizeof timestamp, "%s:%02u %s", left, t_fraction*100/512, right);
This example program will both retrieve the current timestamp from they system OS, and print it out in human readable format. It is similar to #user:2410359 answer, but a little more concise.
#include <stdio.h>
#include <time.h>
#include <sys/time.h>
/*
* timestamp - read and print the current timestamp
* Wade Ryan 2020-09-27
* compile using: g++ timestamp.cpp -o timestamp
*/
int main(int argc, char **argv) {
char timestamp[24];
struct timeval currentTime;
struct tm ts;
gettimeofday(¤tTime, NULL);
long long epoch = (unsigned long long)(currentTime.tv_sec) * 1000 +
(unsigned long long)(currentTime.tv_usec) / 1000;
strftime(timestamp, sizeof(timestamp), "%F %T", localtime(¤tTime.tv_sec));
printf("epoch %lld ms :: %s.%03ld\n", epoch, timestamp, currentTime.tv_usec/1000);
}
Example output:
epoch 1601259041504 ms :: 2020-09-27 21:10:41.504
how i calculate real time in a program of c ....
__________________________start=clock();
----------------------------end=clock();
diff=end-start;
start=124682129.0000000
end =124682129.0000000
result value of diff is 0.0000000000000000000000
i am sorting an array i want to calculate time before sort and end of sort in gcc compiler ......
how i can calculate these times?
real time
execution time
If you want to get the execution time of your program, you can do this:
//some code
#include <time.h>
int main () {
double seconds;
time_t started=time(NULL);
RunSomeFunc();
seconds=difftime(time(NULL),started);
//more code
}
Here you're measuring the execution time of RunSomeFunc.
Docs
difftime
ctime a.k.a time.h
simple program to print time in C
/* localtime example */
#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;
}
I have never programmed in C and therefore it is being a real challenge to write a small piece of software which returns the difference between two dates in seconds.
Just as background information, I implemented a kind of heart beat in a Python application with updates a txt file every 15 seconds. Now I would like to create a C application that checks this txt constantly and in case the difference is greater than 30 seconds, it restarts my computer.
That is how far I went so far:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/types.h>
//Returns the number seconds since the last time the files has been updated
int lastUpdate() {
struct stat attr;
stat("watcher.txt", &attr);
//Gets the last update in the following format: Mon Aug 13 08:23:14 2012
//ctime(&attr.st_mtime);
time_t lastChange = &attr.st_mtime
time_t now = time(0)
//No idea how to implement it :-(
//int seconds = timediff(now, lastChange)
return seconds;
}
//Constantly checks if application is sending heart beats in a 30 seconds time frame
main()
{
while(1 == 1)
{
if(lastUpdate() > 30)
{
sprintf(cmd, "sudo reboot -i -p");
system(cmd);
}
}
}
Would anyone be so nice and give some hints on how to get this working?
Thank you very much!
EDITED:
Final code working without issues:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/types.h>
//Returns the number seconds since the last time the files has been updated
int lastUpdate() {
struct stat attr;
stat("/home/pi/watcher.txt", &attr);
time_t lastChange = attr.st_mtime;
time_t now = time(0);
int seconds = now - lastChange;
return seconds;
}
//Constantly checks if application is sending heart beats in a 30 seconds time frame
main()
{
sleep(120);
while(1 == 1)
{
sleep(1);
if(lastUpdate() > 30)
{
system("sudo reboot -i -p");
}
}
}
You're in luck! time_t is a number, and the timestamps are the time since the beginning of 1970 in seconds. So:
int seconds = now - lastChange;
Oh, and
time_t lastChange = &attr.st_mtime
should be
time_t lastChange = attr.st_mtime
time_t is typically the number of seconds since Jan 1, 1970 0:00:00 UTC (GMT ). So a simply subtraction will work.
time_t lastChange = &attr.st_mtime
time_t now = time(0)
time_t seconds = now - lastChange;
printf("%ll\n", (long long) seconds);
Stricly speaking, time_t may be some other scalar.
A portable solution is to use double difftime(time_t time1, time_t time0);
#include <time.h>
double seconds = difftime(now, lastChange);
printf("%f\n", seconds);
You just need to subtract the time_t's but you have a problem in this line
time_t lastChange = &attr.st_mtime
because stat.st_mtime is of type time_t not time_t *, so you should change it to
time_t lastChange = attr.st_mtime
and then
return new - lastChange;
and also, check stat("watcher.txt", &attr) != -1
How can I set, in C, the time zone for Saint Pierre and Miquelon (PMST3PMDT) with this format:
set TZ=tzn[+ | –]hh[:mm[:ss] ][dzn]
If you look at the documentation of _tzset, you can read that:
tzn
Three-letter time-zone name, such as PST. You must specify the correct offset from local time to UTC.
What about time zone names of 4 letters (PMDT) or 5 letters (EASST) ?
Here is the list of all the time zone abbreviations: wikiepedia
Here is my simple code in C to test _tzset:
#include <stdio.h>
#include <stdlib.h>
#include <sys/timeb.h>
#include <time.h>
//add _CRT_SECURE_NO_WARNINGS in the project properties "preprocessor definitions"
int main(int argc, char* argv[])
{
time_t t;
struct tm * now;
_putenv("TZ=PST8PDT"); // for pacific standard time, there is no problem
_tzset();
t = time(0);
now = localtime( & t );
printf("time: %d:%d \nisdst:%d\n", now->tm_hour, now->tm_min, now->tm_isdst);
printf("_daylight=%d\n", _daylight);
printf( "_timezone=%d\n", _timezone);
printf( "_tzname[0]=%s\n", _tzname[0]);
printf( "_tzname[1]=%s\n", _tzname[1]);
return 0;
}
*I'm using windows8, visual studio 2012
From what I see in the timezone database on Ubuntu:
/usr/share/zoneinfo/zone.tab
The timezone you want to use is named America/Miquelon.
So you would want to do this:
setenv("TZ", "America/Miquelon", 1);
tzset();
To force the timezone to Saint Pierre & Miquelon.
I do not know whether that would work under MS-Windows though...
I have something like this:
char *current_day, *current_time;
system("date +%F");
system("date +%T");
It prints the current day and time in the stdout, but I want to get this output or assign them to the current_day and current_time variables, so that I can do some processing with those values later on.
current_day ==> current day
current_time ==> current time
The only solution that I can think of now is to direct the output to some file, and then read the file and then assign the values of date and time to current_day and current_time. But I think this is not a good way. Is there any other short and elegant way?
Use time() and localtime() to get the time:
#include <stdio.h>
#include <time.h>
int main()
{
time_t t = time(NULL);
struct tm tm = *localtime(&t);
printf("now: %d-%02d-%02d %02d:%02d:%02d\n", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
}
strftime (C89)
Martin mentioned it, here's an example:
main.c
#include <assert.h>
#include <stdio.h>
#include <time.h>
int main(void) {
time_t t = time(NULL);
struct tm *tm = localtime(&t);
char s[64];
size_t ret = strftime(s, sizeof(s), "%c", tm);
assert(ret);
printf("%s\n", s);
return 0;
}
GitHub upstream.
Compile and run:
gcc -std=c89 -Wall -Wextra -pedantic -o main.out main.c
./main.out
Sample output:
Thu Apr 14 22:39:03 2016
The %c specifier produces the same format as ctime.
One advantage of this function is that it returns the number of bytes written, allowing for better error control in case the generated string is too long:
RETURN VALUE
Provided that the result string, including the terminating null byte, does not exceed max bytes, strftime() returns the number of bytes (excluding the terminating null byte) placed in the array s. If the length of the result string (including the terminating null byte) would exceed max bytes, then strftime() returns 0, and the contents of the array are undefined.
Note that the return value 0 does not necessarily indicate an error. For example, in many locales %p yields an empty string. An empty format string will likewise yield an empty string.
asctime and ctime (C89, deprecated in POSIX 7)
asctime is a convenient way to format a struct tm:
main.c
#include <stdio.h>
#include <time.h>
int main(void) {
time_t t = time(NULL);
struct tm *tm = localtime(&t);
printf("%s", asctime(tm));
return 0;
}
Sample output:
Wed Jun 10 16:10:32 2015
And there is also ctime() which the standard says is a shortcut for:
asctime(localtime())
As mentioned by Jonathan Leffler, the format has the shortcoming of not having timezone information.
POSIX 7 marked those functions as "obsolescent" so they could be removed in future versions:
The standard developers decided to mark the asctime() and asctime_r() functions obsolescent even though asctime() is in the ISO C standard due to the possibility of buffer overflow. The ISO C standard also provides the strftime() function which can be used to avoid these problems.
C++ version of this question: How to get current time and date in C++?
Tested in Ubuntu 16.04.
time_t rawtime;
time ( &rawtime );
struct tm *timeinfo = localtime ( &rawtime );
You can also use strftime to format the time into a string.
To expand on the answer by Ori Osherov
You can use the WinAPI to get the date and time, this method is specific to Windows, but if you are targeting Windows only, or are already using the WinAPI then this is definitly a possibility1:
You can get both the time and date by using the SYSTEMTIME struct. You also need to call one of two functions (either GetLocalTime() or GetSystemTime()) to fill out the struct.
GetLocalTime() will give you the time and date specific to your time zone.
GetSystemTime() will give you the time and date in UTC.
The SYSTEMTIME struct has the following members:
wYear, wMonth, wDayOfWeek, wDay, wHour, wMinute, wSecond and wMilliseconds
You then need to just access the struct in the regular way
Actual example code:
#include <windows.h> // use to define SYSTEMTIME , GetLocalTime() and GetSystemTime()
#include <stdio.h> // For printf() (could otherwise use WinAPI equivalent)
int main(void) { // Or any other WinAPI entry point (e.g. WinMain/wmain)
SYSTEMTIME t; // Declare SYSTEMTIME struct
GetLocalTime(&t); // Fill out the struct so that it can be used
// Use GetSystemTime(&t) to get UTC time
printf("Year: %d, Month: %d, Day: %d, Hour: %d, Minute:%d, Second: %d, Millisecond: %d", t.wYear, t.wMonth, t.wDay, t.wHour, t.wMinute, t.wSecond, t.wMilliseconds); // Return year, month, day, hour, minute, second and millisecond in that order
return 0;
}
(Coded for simplicity and clarity, see the original answer for a better formatted method)
The output will be something like this:
Year: 2018, Month: 11, Day: 24, Hour: 12, Minute:28, Second: 1, Millisecond: 572
Useful References:
All the WinAPI documentation (most already listed above):
GetLocalTime()
GetSystemTime()
SYSTEMTIME
Time Functions
An extremely good beginners tutorial on this subject by ZetCode:
https://zetcode.com/gui/winapi/datetime/
Simple operations with datetime on Codeproject:
https://www.codeproject.com/Articles/5546/WinAPI-Simple-Operations-with-datetime
1: As mentioned in the comments in Ori Osherov's answer ("Given that OP started with date +%F, they're almost certainly not using Windows. – melpomene Sep 9 at 22:17") the OP is not using Windows, however since this question has no platform specific tag (nor does it mention anywhere that the answer should be for that particular system), and is one of the top results when Googling "get time in c" both answers belong here, some users searching for an answer to this question may be on Windows and therefore will be useful to them.
Timespec has day of year built in.
http://pubs.opengroup.org/onlinepubs/7908799/xsh/time.h.html
#include <time.h>
int get_day_of_year(){
time_t t = time(NULL);
struct tm tm = *localtime(&t);
return tm.tm_yday;
}`
The answers given above are good CRT answers, but if you want you can also use the Win32 solution to this. It's almost identical but IMO if you're programming for Windows you might as well just use its API (although I don't know if you are programming in Windows).
char* arrDayNames[7] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
SYSTEMTIME st;
GetLocalTime(&st); // Alternatively use GetSystemTime for the UTC version of the time
printf("The current date and time are: %d/%d/%d %d:%d:%d:%d", st.wDay, st.wMonth, st.wYear, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
printf("The day is: %s", arrDayNames[st.wDayOfWeek]);
Anyway, this is a Windows solution. I hope it will be helpful for you sometime!
I was using command line C-compiler to compile these and it completely drove me bonkers as it refused to compile.
For some reason my compiler hated that I was declaring and using the function all in one line.
struct tm tm = *localtime(&t);
test.c
test.c(494) : error C2143: syntax error : missing ';' before 'type'
Compiler Status: 512
First declare your variable and then call the function. This is how I did it.
char todayDateStr[100];
time_t rawtime;
struct tm *timeinfo;
time ( &rawtime );
timeinfo = localtime ( &rawtime );
strftime(todayDateStr, strlen("DD-MMM-YYYY HH:MM")+1,"%d-%b-%Y %H:%M",timeinfo);
printf("todayDateStr = %s ... \n", todayDateStr );
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
struct date
{
int month;
int day;
int year;
};
int calcN(struct date d)
{
int N;
int f(struct date d);
int g(int m);
N = 1461 * f(d) / 4 + 153 * g(d.month) / 5 + d.day;
if(d.year < 1700 || (d.year == 1700 && d.month < 3))
{
printf("Date must be after February 29th, 1700\n");
return 0;
}
else if(d.year < 1800 || (d.year == 1800 && d.month < 3))
N += 2;
else if(d.year < 1900 || (d.year == 1900 && d.month < 3))
N += 1;
return N;
}
int f(struct date d)
{
if(d.month <= 2)
d.year -= 1;
return d.year;
}
int g(int m)
{
if(m <=2)
m += 13;
else
m += 1;
return m;
}
int main(void)
{
int calcN(struct date d);
struct date d1, d2;
int N1, N2;
time_t t;
time(&t);
struct tm *now = localtime(&t);
d1.month = now->tm_mon + 1;
d1.day = now->tm_mday;
d1.year = now->tm_year + 1900;
printf("Today's date: %02i/%02i/%i\n", d1.month, d1.day, d1.year);
N1 = calcN(d1);
printf("Enter birthday (mm dd yyyy): ");
scanf("%i%i%i", &d2.month, &d2.day, &d2.year);
N2 = calcN(d2);
if(N2 == 0)
return 0;
printf("Number of days since birthday: %i\n", N1 - N2);
return 0;
}
#include <stdio.h>
int main() {
char *pts; /* pointer to time string */
time_t now; /* current time */
char *ctime();
(void) time(&now);
printf("%s", ctime(&now));
return(0);
}
Sample output:
Sat May 14 19:24:54 2022
This is the easiest way. I haven't even used time.h.
Be advised: The output produced has a newline at the end.
instead of files use pipes and if u wana use C and not C++ u can use popen like this
#include<stdlib.h>
#include<stdio.h>
FILE *fp= popen("date +F","r");
and use *fp as a normal file pointer with fgets and all
if u wana use c++ strings, fork a child, invoke the command and then pipe it to the parent.
#include <stdlib.h>
#include <iostream>
#include <string>
using namespace std;
string currentday;
int dependPipe[2];
pipe(dependPipe);// make the pipe
if(fork()){//parent
dup2(dependPipe[0],0);//convert parent's std input to pipe's output
close(dependPipe[1]);
getline(cin,currentday);
} else {//child
dup2(dependPipe[1],1);//convert child's std output to pipe's input
close(dependPipe[0]);
system("date +%F");
}
// make a similar 1 for date +T but really i recommend u stick with stuff in time.h GL
#include<stdio.h>
using namespace std;
int main()
{
printf("%s",__DATE__);
printf("%s",__TIME__);
return 0;
}