Probablemente estaba cansado y no podía ser feliz ni de lado ni verticalmente, me puse de pie y fruncí el ceño, no había razón para esta tristeza. Como programador junior que no ha podido controlar el tiempo del sistema durante mucho tiempo, después de unos días de exploración, lo resumí por capricho y lo compartí con mis amigos. Los amigos pueden estar deseando que llegue, ¿cómo se convierte un blog en una fuente inagotable de control del tiempo ? De nada sirve decir más, ¡empieza el texto!
contenido
time_t tipo: hora del calendario
función de tiempo: obtenga la hora actual en forma de tiempo de calendario
estructura tm: tiempo de desintegración (tiempo de desgarro)
Función gmtime: convierte el tiempo del calendario en tiempo de descomposición UTC
función asctime: convierte el tiempo descompuesto en una cadena
función ctime: convierte el tiempo del calendario en una cadena
función difftime: encuentra la diferencia horaria
función mktime: inversión de polos
¿Cuál es la fecha de hoy?
Comencemos con el primer código de este blog y aprendamos cómo obtener la fecha y hora actuales:
//time01
#include <stdio.h>
#include <time.h>
void put_date(const struct tm* timer)
{
char* wday_name[] = { "日","一","二","三","四","五","六" };
printf("%4d年%02d月%02d日(%s)%02d时%02d分%02d秒", timer->tm_year + 1900, //年
timer->tm_mon + 1, //月
timer->tm_mday, //日
wday_name[timer->tm_wday], //星期
timer->tm_hour, //时
timer->tm_min, //分
timer->tm_sec); //秒
}
int main()
{
time_t current; //日历时间
struct tm* timer; //分解时间（结构体）
time(¤t); //获取当前时间
timer = localtime(¤t); //转换成分解时间（本地时间）
printf("当前日期和时间是");
put_date(timer);
printf("。\n");
return 0;
}time_t tipo: hora del calendario
El tipo time_t, también conocido como calendar time , es en realidad un tipo aritmético que puede realizar operaciones de suma, resta, multiplicación y división al igual que los tipos int y double. Qué tipo es equivalente a depende del entorno de programación (no solo el tipo de tiempo del calendario, sino también su valor específico). Usarlo requiere agregar la definición del archivo de encabezado <time.h>. En la mayoría de los entornos de compilación, el tipo time_t es equivalente al tipo int o al tipo long, y el Greenwich Mean Time, es decir, el número de segundos transcurridos después del 1 de enero de 1970 0:0:0:0, se utiliza como el valor específico del tiempo del calendario.
función de tiempo: obtenga la hora actual en forma de tiempo de calendario
Y mira la siguiente tabla:
| tiempo | |
| archivo principal | #include <tiempo.h> |
| Formato | time_t time(time_t *temporizador); |
| Características | Determina la hora actual del calendario. La representación de este valor no está definida. |
| valor de retorno | Devuelve la hora del calendario calculada con la mejor aproximación en el entorno en el que se compila. Si la hora del calendario no es válida, el valor de retorno (time_t) es 1. Cuando el temporizador no es un puntero nulo, el valor de retorno se asigna al objeto al que apunta el temporizador. |
Sobre la base de encontrar la hora del calendario, esta función almacena la hora del calendario en el objeto señalado por el parámetro timer y devuelve la hora del calendario al mismo tiempo. Por lo tanto, podemos elegir varios métodos de llamada según diferentes usos y preferencias personales.
Pasamos un puntero a la variable actual como argumento a la función de tiempo usando time(¤t);.
estructura tm: tiempo de desintegración (tiempo de desgarro)
Intenta usar el tipo time_t para representar el tiempo, sabemos que representa algo que nos resulta extremadamente difícil de entender:
Por lo tanto, podemos usar otro método de representación, que se llama el tipo de estructura tm del tiempo de desgarro .
Echemos un vistazo a la estructura tm :
struct tm{
int tm_sec; //秒（0-61）
int tm_min; //分（0-59）
int tm_hour; //时（0-23）
int tm_mday; //日（0-31）
int tm_mon; //从一月开始的月份（0-11）
int tm_year; //从1900开始的年份
int tm_wday; //星期：星期日-星期六（0-6）
int tm_yday; //从1月1日开始的天数（0-365）
}；Los amigos pueden comprender el valor que representa cada miembro a través de los comentarios en el código. Y cuando buscamos el segundo miembro, el valor tm_min se establece en 0-61 , porque se tiene en cuenta el "segundo bisiesto" .
función de hora local: convierte la hora del calendario en hora descompuesta que representa la hora local
La función localtime (a través de la estructura tm) se utiliza para convertir un valor de tiempo de calendario en un tiempo descompuesto.
| hora local | |
| archivo principal | #include <tiempo.h> |
| Formato | struct tm*localtime(const time_t *temporizador); |
| Características | Convierte la hora del calendario señalada por el temporizador en la hora descompuesta expresada en la hora local |
| valor de retorno | Devuelve un puntero al objeto convertido. |
Como el literal de locattime está indicado por cuatro, lo que obtienes después de la conversión es la hora local. Veamos su representación:
Finalmente, analicemos el programa time01.
(1) En la función principal, utilizamos la función de tiempo para obtener el tiempo actual en forma de tiempo de calendario time_t y convertirlo en un tiempo descompuesto, es decir, una estructura tm.
(2) Cómo usar put_date para aceptar la estructura convertida y mostrar el tiempo de descomposición en la era gregoriana;
(3) Finalmente, agregue 1900 a tm_year y agregue 1 a tm_mon. Dado que tm_wday que representa la semana corresponde de 0 a 6 de domingo a sábado, la matriz wday_name se puede usar para convertirlo a la cadena china "日", " Uno",..."Seis" y se muestra.
Función gmtime: convierte el tiempo del calendario en tiempo de descomposición UTC
Es demasiado tacaño hablar solo de la hora local. A continuación, traeré la hora coordinada (es decir, UTC) a mis amigos.
La función gmtime es la función utilizada para ejecutar UTC, consulte la tabla a continuación;
| gmtime | |
| archivo principal | #include <tiempo.h> |
| Formato | struct tm *gmtime(const time_t *timer); |
| Características | Convierte el tiempo del calendario señalado por el temporizador al tiempo descompuesto expresado en tiempo coordinado |
| valor de retorno | Devuelve un puntero al objeto convertido. |
Echemos un vistazo a cómo usar la función gmtime, el código es en realidad el mismo que time01:
//time02
#include <stdio.h>
#include <time.h>
void put_date(const struct tm* timer)
{
char* wday_name[] = { "日","一","二","三","四","五","六" };
printf("%4d年%02d月%02d日(%s)%02d时%02d分%02d秒", timer->tm_year + 1900,
timer->tm_mon + 1,
timer->tm_mday,
wday_name[timer->tm_wday],
timer->tm_hour,
timer->tm_min,
timer->tm_sec);
}
int main()
{
time_t current;
struct tm* timer;
time(¤t);
timer = gmtime(¤t);
printf("当前日期和时间用UTC表示是");
put_date(timer);
printf("。\n");
return 0;
}De hecho, es para cambiar timer = localtime(¤t); a timer = gmtime(¤t); .
función asctime: convierte el tiempo descompuesto en una cadena
Permítanme compartir una función con mis amigos, puede convertir el tiempo de descomposición en una cadena y simplemente puede representar la fecha y la hora actuales, ¿por qué no hacerlo? Y mira el siguiente código:
//time03
#include <stdio.h>
#include <time.h>
int main()
{
time_t current = time(NULL);
printf("当前日期和时间：%s", asctime(localtime(¤t)));
return 0;
}La función asctime es una función que convierte el tiempo descompuesto en forma de cadena. Las cadenas que genera y devuelve están en el orden de semana/mes/día/hora/minuto/segundo/año de izquierda a derecha, separadas por caracteres de espacio en blanco y dos puntos ":" .
Podemos ver que hay 3 letras al comienzo de sus palabras en inglés en la semana y el mes respectivamente (la primera letra es una letra mayúscula y la segunda y la tercera son letras minúsculas). Echemos un vistazo a su tabla de nuevo:
| asctime | |
| archivo principal | #include <tiempo.h> |
| Formato | char *asctime(const struct tm *timeptr); |
| Características | Convierta el tiempo de descomposición de la estructura señalada por timeptr en una cadena de la siguiente forma dom 10 abr 13:13:09:00 2022 |
| valor de retorno | Devuelve un puntero al objeto convertido. |
función ctime: convierte el tiempo del calendario en una cadena
Al usar la función asctime, para convertir el tiempo del calendario del tipo time_t en el tiempo de descomposición de la estructura tm, necesitamos llamar a la función localtime. De esta forma, se necesitan dos pasos para convertir la hora del calendario en una cadena, lo cual es demasiado engorroso. La función ctime es diferente, ¡solo toma un paso!
//time04
#include <stdio.h>
#include <time.h>
int main()
{
time_t current = time(NULL);
printf("当前日期和时间：%s", ctime(¤t));
return 0;
}La tabla de tiempos es la siguiente:
| ctime | |
| archivo principal | #include <tiempo.h> |
| Formato | char *ctime(const time_t *temporizador); |
| Características | Convierta la hora del calendario señalada por el temporizador a la hora local en la misma forma de cadena que la función asctime, equivalente a asctime(localtime(timer)) |
| valor de retorno | Devuelve el puntero devuelto por la función asctime con el tiempo de descomposición como parámetro real |
función difftime: encuentra la diferencia horaria
A continuación, le mostraré cómo usar el tiempo de calendario obtenido por la función de tiempo para calcular el tiempo de procesamiento. Código primero:
//time05
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a, b, c, d;
int x;
time_t start, end;
srand(time(NULL));
a = rand() % 100;
b = rand() % 100;
c = rand() % 100;
d = rand() % 100;
printf("%d+%d+%d+%d等于多少：", a, b, c, d);
start = time(NULL);
while (1)
{
scanf("%d", &x);
if (x == a + b + c + d)
break;
printf("回答错误！！\n请重新输入：");
}
end = time(NULL);
printf("用时%.0f秒。\n", difftime(end, start));
return 0;
}p rintf("Tiempo %.0f segundos.\n", difftime(fin, inicio)); Se usa para encontrar la diferencia entre dos horas del calendario llamando a la función difftime. Su uso es sumamente sencillo, basta con dar dos valores de tipo time_t como parámetros (end-start), y devolver la diferencia horaria en forma de valor de tipo doble en segundos.
Echemos un vistazo a la tabla de tiempos diferenciales de nuevo:
| diferencia de tiempo | |
| archivo principal | #include <tiempo.h> |
| Formato | double difftime(time_t time1, time_t time0); |
| Características | Calcular la diferencia entre dos tiempos calendario time1 - time0 |
| valor de retorno | Representa la diferencia de tiempo obtenida en segundos, devuelta como un doble |
pregunta por la semana
función mktime: inversión de polos
He descrito cómo convertir la hora del calendario en hora descompuesta. Ahora hablaré sobre cómo convertir la hora descompuesta de la hora local en hora del calendario. Eso es usar la función mktime, que es lo opuesto a la conversión realizada por la función localtime. .
而且，这函数还带来了意外之喜。它可以计算并设定结构体的星期和一年中经过的天数的值。利用该功能的话，咱只需设定分解时间的年/月/日并调用mktime 函数，就能求出对应的星期。
我们来看看它的流程图：
这可真是两极反转啊！
最后，用一段华丽的代码了却此博客：
//time06
#include <time.h>
#include <stdio.h>
int dayofweek(int year, int month, int day)
{
struct tm t;
t.tm_year = year - 1900;
t.tm_mon = month - 1;
t.tm_mday = day;
t.tm_hour = 0;
t.tm_min = 0;
t.tm_sec = 0;
t.tm_isdst = -1;
if (mktime(&t) == (time_t)-1)
return -1;
return t.tm_wday;
}
int main()
{
int y, m, d, w;
char* ws[] = { "日","一","二","三","四","五","六" };
printf("求星期。\n");
printf("年："); scanf("%d", &y);
printf("月："); scanf("%d", &m);
printf("日："); scanf("%d", &d);
w = dayofweek(y, m, d);
if (w != -1)
printf("这一天是星期%s。\n", ws[w]);
else
printf("无法求出星期。\n");
return 0;
}
time06 中定义的dayofweek 函数会根据接受的年/月/日这3个值来生成分解时间，然后再调用mktime 函数，之后函数会通过”附赠“的功能直接返回成员函数tm_wday 中设定的值，值为0是星期日……
此外，mktime函数返回错误时，说明程序有可能求出了错误的星期数值，因此函数dayofweek 会返回 -1。
完结
很感激阅读到这里的你，相信阅读完的你已经成为了掌控时间的强者了吧！精彩并不止于这些，学有余力的小伙伴可以看看下面这些博客，都是有着极多的技巧与干货❤！
C语言小游戏（一）----猜数游戏_施律.的博客-CSDN博客_c语言猜数游戏次数限制
《斗破CPP》 第壹章 ---- 初窥CPP_施律.的博客-CSDN博客
《斗破CPP》 第贰章（上） ---- 初识分支句_施律.的博客-CSDN博客
如果觉得本篇博客对正在学习编程的你有帮助的话，请给施律.多一点的支持与关注！未来的一段时间里施律.将和小伙伴们一起在编程的道路是越来越远，希望下次的我能为大家奉上更好的博客内容，也希望下次的博客有你！