How can c ++ obtain the system time?
// Solution-advantage: only the C standard library is used; disadvantage: only seconds are allowed
# Include <time. h>
# Include <stdio. h>
Int main (void)
{
Time_t t = time (0 );
Char TMP [64];
Strftime (TMP, sizeof (TMP), "% Y/% m/% d % x % A % j day % Z this year", localtime (& T ));
Puts (TMP );
Return 0;
}
Size_t strftime (char * strdest, size_t maxsize, const char * format, const struct TM * timeptr );
Generate a string based on the format string.
Struct TM * localtime (const time_t * timer );
Obtain the local time. the result obtained by localtime is returned by the structure TM.
The returned string can be in the following format:
% A the abbreviation of the day of the week. Eg: TUE
% A full name of the day of the week. Eg: Tuesday
The abbreviation of % B month name.
% B full name of the month name.
% C the local date time is better than the string.
% D indicates the day of the month (range: 00 to 31) with a number ). Date
% H indicates the hour in the 24-hour format (ranging from 00 to 23 ).
% I represents the hour in 12-hour format (range: 01 to 12 ).
% J indicates the day of the year (range: 001 to 366 ).
The number of % m months (ranging from 1 to 12 ).
% M minutes.
% P uses ''am'' or ''pm ''to indicate the local time.
% S seconds.
% U indicates the week of the current year. The first week starts from the first Sunday.
% W indicates the week of the current year. The first week starts from the first Monday.
% W indicates the day of the week by number (0 indicates Sunday ).
% X date representation without time.
% X does not include the time representation of the date. Eg: 15:26:30
The two digits % Y indicate the year (range: 00 to 99 ).
% Y indicates the complete year number, that is, the four-digit number. Example: 2008
% Z (% Z) Time Zone or abbreviation. Eg: China Standard Time
% Characters.
// Solution 2 advantages: accurate to milliseconds; disadvantage: Windows API is used
# Include <windows. h>
# Include <stdio. h>
Int main (void)
{
Systemtime sys;
Getlocaltime (& Sys );
Printf ("% 4D/% 02d/% 02d % 02d: % 02d: % 02d. % 03d week % 1D/N ", sys. wyear, sys. wmonth, sys. wday, sys. whour, sys. wminute, sys. wsecond, sys. wmilliseconds, sys. wdayofweek );
Return 0;
}
// Solution 3. Advantages: using system functions, you can modify the system time.
// This file must be a C ++ File
# Include <stdlib. h>
# Include <iostream>
Using namespace STD;
Void main ()
{
System ("time ");
}
// Solution 4: Convert the current time to seconds, and then use the corresponding time to convert
// This file must be a C ++ File
# Include <iostream>
# Include <ctime>
Using namespace STD;
Int main ()
{
Time_t now_time;
Now_time = Time (null );
Cout <now_time;
Return 0;
}
1. Obtain the time:Use the time () function to obtain the calendar time. Its prototype is time_t time (time_t * timer); # include "stdafx. H "# include" time. H "# include" stdio. H "# include" stdlib. H "int main (void) {struct TM t; // defines the TM time structure, which is used to store the time_t t_of_day data information in the time format; // defines the time_t time structure T. tm_year = 2006-1900; // calculate the time t based on January 1, 1900. tm_mon = 6; // assign a value to the struct T. tm_mday = 1; T. tm_hour = 0; T. tm_min = 0; T. tm_sec = 1; T. tm_isdst = 0; t_of_day = mktime (& T); // use the mktime () function to convert the time represented in the TM structure to a calendar time: time_t variable . The function prototype is as follows: time_t mktime (struct TM * timeptr); The ctime () function (the parameter is in the time_t structure) displays the time in a fixed format, the returned value is a char * string. Return 0 ;}
2. Storage of time is stored through two predefined structures:1. The calendar time is represented by the time_t data type. The time expressed by time_t (calendar time) is from a time point (for example, January 1, 1970 00:00:00) the number of seconds. In time. h, we can also see that time_t is a long integer: # ifndef _ time_t_definedtypedef long time_t; /* Time Value */# DEFINE _ time_t_defined/* avoid repeatedly defining time_t */# endif2. In Standard C/C ++, we can use the TM structure to obtain the date and time. The TM structure is in time. the definition in H is as follows: struct TM {int tm_sec;/* Second-value range: [0, 59] */INT tm_min; /* minute-value range: [] */INT tm_hour;/* Time-value range: [] */INT tm_mday; /* date in a month-value range: [1, 31] */INT tm_mon;/* month (starting from January 1, January, 0 indicates January 1, January) -The value range is [0, 11] */INT tm_year;/* year The value is equal to the actual year minus 1900 */INT tm_wday;/* the week-value range is [], where 0 represents Sunday, 1 represents Monday, and so on */INT tm_yday; /* The number of days starting from January 1, 0,365-the value range is []. 0 indicates January 1, and so on. */INT tm_isdst;/* indicates the identifier of the hour, when the sequence is executed, tm_isdst is positive. When the sequence is not implemented, the tm_isdst value is 0. If the sequence is unknown, the tm_isdst () value is negative. */};
3. display of time:Time. the H header file provides the asctime () function (the parameter is a TM structure pointer) and ctime () function (the parameter is a time_t structure) to display the time in a fixed format, both return values are char * strings. The returned time format is: day of the week, month, hour, minute, second, year, N, 0, time. H also provides two different functions to convert the calendar time (an integer expressed in time_t) to the time format we usually see separately displaying year, month, day, hour, minute, and second.
TM: struct TM * gmtime (const time_t * timer); The gmtime () function converts the calendar time to the world's Standard Time (GMT ), returns a TM struct to save the time struct TM * localtime (const time_t * timer). The localtime () function converts the calendar time to the local time # include <stdafx. h> # include <time. h> # include <stdio. h> # include <stdlib. h> int main (void) {struct TM * local, * PTR; // defines the TM structure pointer to store the time information time_t; // time structure or object t = time (null); // obtain the current system calendar time // use the time () function to obtain the calendar time ), // Its prototype is time_t time (tim E_t * timer); Local = localtime (& T); // The localtime () function converts the calendar time to the local time printf ("Local hour is: % d/N ", local-> tm_hour); // specifies the time member printf ("UTC hour is: % d/N", local-> tm_hour) of the output TM struct ); // local = gmtime (& T); // The gmtime () function converts the calendar time to the world standard time (GMT ), // return a TM struct to save the time PTR = gmtime (& T ); // convert the calendar time to the world standard time printf ("the UTC time is % s/n", asctime (PTR )); // format and output the world standard time printf ("The local time is % s/n", ctime (& T); // output the local time/* asctime () function The number (the parameter is a TM structure pointer) and the ctime () function (the parameter is a time_t structure) display the time in a fixed format. The return values of both are char * strings. The returned time format is: day of the week, month, hour, minute, second, year, N/0 */return 0 ;}
4. Time difference calculation:Function used: the timing function in C/C ++ is clock (), and the related data type is clock_t. The clock function is defined as follows in msdn: clock_t clock (void); the function returns from "enable this program process" to "program call clock () the number of clock units (clock tick) between functions. clock_t is a long integer and the Data Type of the storage time. In time. in the H file, a constant clocks_per_sec is also defined to indicate the number of clock units in a second. Its definition is as follows: # define clocks_per_sec (clock_t) 1000) every 1‰ seconds (1 millisecond), the value returned by calling the clock () function is increased by 1, and the length of the clock timing unit is 1 millisecond, so the timing accuracy is also 1 millisecond, can we change the definition of clocks_per_sec to a greater value, so that the timing accuracy is higher? This is not acceptable. In standard C/C ++, the minimum unit of time is one millisecond. Double difftime (time_t time1, time_t time0); this function is used to calculate the time difference. # Include "stdafx. H "# include" time. H "# include" stdio. H "# include" stdlib. H "int main (void) {time_t c_start, t_start, c_end, t_end; c_start = clock (); t_start = Time (null); System (" pause "); c_end = clock (); t_end = Time (null); printf ("the pause used % F The MS by time (). /n ", difftime (c_end, c_start); printf (" the pause used % f s by clock (). /n ", difftime (t_end, t_start); System (" pause "); Return 0 ;}5, other use of time As the seed of a random number, because the time is actually a long integer of the double type, obtained through the time (null) function, as srand (Time (null )) is better. # Include "stdafx. H "# include" time. H "# include" stdio. H "# include" stdlib. H "int main (void) {srand (Time (null); // sets the seed. If you comment out this function, for (INT I = 0; I <100; I ++) {printf ("% d/T", Rand ());} system ("pause"); Return 0;
