¿Alguien puede decirme qué función en lenguaje C puede registrar el tiempo?
Resumen:
A partir de la introducción de conceptos básicos, se discuten las estructuras de datos y funciones utilizadas en las operaciones de fecha y hora en C/C, y Se elabora a partir de los aspectos de sincronización, recopilación de tiempo, cálculo de tiempo y formato de visualización. Este artículo también utiliza una gran cantidad de ejemplos para mostrarle el uso detallado de varias funciones y estructuras de datos declaradas en el archivo de encabezado time.h.
Palabras clave:
UTC (Tiempo Universal Coordinado), hora del calendario (hora del calendario), época (punto de tiempo), tick del reloj (unidad de tick del reloj).
1. Concepto
En C/C, las operaciones de cadenas tienen muchos problemas que vale la pena señalar. Asimismo, hay mucho que destacar sobre la manipulación del tiempo por parte de C/C. Recientemente, muchos internautas del grupo técnico han hecho muchas preguntas sobre el funcionamiento, adquisición y visualización de la hora en lenguaje C. A continuación, en este artículo, el autor presentará principalmente el uso de hora y fecha en C/C.
Al aprender muchas bibliotecas C/C, podrá tener muchas maneras de operar y utilizar su tiempo. Pero antes de eso, es necesario conocer algunos conceptos de “hora” y “fecha”, principalmente los siguientes puntos:
Tiempo Universal Coordinado (UTC): Tiempo Universal Coordinado (Tiempo Universal Coordinado), también conocido como Hora Universal Coordinada, también conocida como Hora Media de Greenwich (GMT). Por ejemplo, la diferencia horaria entre China continental y UTC es 8, que es UTC 8. Estados Unidos es UTC-5.
Hora del calendario: La hora del calendario es el tiempo expresado por "el número de segundos que han pasado desde un punto de tiempo estándar hasta este tiempo". Este punto de tiempo estándar será diferente para diferentes compiladores, pero para un sistema de compilación, este punto de tiempo estándar no cambia. El tiempo del calendario correspondiente al tiempo en el sistema de compilación se mide en función de este punto de tiempo estándar. Se puede decir que la hora del calendario es "hora relativa", pero no importa en qué zona horaria se encuentre, la hora del calendario en el mismo punto horario estándar es la misma.
Epoca: momento en el tiempo. El punto de tiempo es un número entero en C/C estándar, expresado por el número de segundos entre la hora actual y el punto de tiempo estándar (es decir, la hora del calendario).
Clock tick: unidad de tick del reloj (no se llama tick del reloj). La hora de la unidad de tictac del reloj está controlada por el procesador central. El latido del reloj no es un ciclo de reloj de la CPU, sino una unidad de tiempo básica de C/C.
Podemos utilizar el archivo de encabezado time.h en la biblioteca estándar ANSI. Los métodos utilizados para definir la hora y la fecha en este archivo de encabezado tienen un estilo de lenguaje C obvio en términos de definición y denominación de estructuras. A continuación, explicaré cómo utilizar las funciones de fecha y hora en C/C++.
Paso 2: Temporización
La función de temporización en C/C es reloj(), y su tipo de datos relacionado es reloj_t. En MSDN, la definición de Chad de la función de reloj es la siguiente:
clock_t clock(void);
Esta función devuelve los ticks del reloj de la CPU entre "iniciar el proceso del programa" y "llamar a la función clock() en el programa" Número, llamado wal -reloj en MSDN. Entre ellos, clock_t es un tipo de datos utilizado para ahorrar tiempo. Podemos encontrar su definición en el archivo time.h:
#ifndef _CLOCK_T_DEFINED
typedef long clock_t
;#Definition_clock_time_Definition
#endif
Obviamente, clock_t es un entero largo.
En el archivo time.h, también se define una constante CLOCKS_PER_SEC para indicar cuántas unidades de temporización de reloj habrá en un segundo. Se define de la siguiente manera:
#Defina el número de relojes por segundo ((. clock_t) 1000)
Como puede ver, cada milésima de segundo (1 milisegundo), el valor devuelto al llamar a la función clock() aumenta en 1. Por ejemplo, puedes usar la fórmula clock()/CLOCKS_PER_SEC para calcular el tiempo de ejecución del proceso en sí:
void elapsed_time()
{
printf ("Tiempo de ejecución: u segundos. \n ",clock()/CLOCKS_PER_SEC);
}
Por supuesto, también puedes usar la función de reloj para calcular cuánto tiempo lleva su máquina para ejecutar un ciclo O cuánto tiempo lleva procesar otros eventos:
#Contiene "stdio.h"
#Contiene "stdlib.h"
#Contiene "time.h ”
int main(void)
{
Largo I = 1000000 l;
clock_t inicia , termina;
Duración doble;
/*Mide la duración del evento*/
printf("El tiempo para hacer que ld esté vacío es", I);
inicio = reloj();
Cuando(i-)
finalizar = reloj();
duración = (doble)(finish-start )/RELOJES _ POR _ SEG;
printf( "f segundos\n ", duración
Sistema("pausa"); p>
}
En la máquina del autor, los resultados de la ejecución son los siguientes:
El tiempo para hacer 1.000.000 de bucles vacíos es 0,03000 segundos
Arriba vemos que la longitud de la unidad de sincronización del reloj es de 1 ms, por lo que la precisión de la sincronización es de 1 ms. Entonces, ¿puedes cambiar la definición de CLOCKS_PER_SEC para que sea más grande y aumentar la precisión de la sincronización? Al intentarlo, descubrirás que es imposible. En C/C estándar, la unidad de tiempo mínima es 1 milisegundo.
3. Estructuras de datos relacionadas con la fecha y la hora
En C/C estándar, podemos obtener la fecha y la hora a través de la estructura tm, que se define en time.h De la siguiente manera :
#ifndef _TM_DEFINED
Estructura tm {
int tm _ sec/* segundos – el intervalo de valores es */
int tm _ min/* el intervalo de valor de minuto es */
int tm _ hora/* el intervalo de valor de cuando es */
int tm _ mday/* en un mes La fecha: el rango de valores es, donde 0 significa domingo, 1 significa lunes, y así sucesivamente */
int tm _ yday/*El número de días de cada año a partir del 1 de octubre de 65438 - el rango de valores es , donde 0 representa el 1 de octubre de 65438, 1 representa el 2 de octubre de 65438, y así sucesivamente */
int tm _ isdst/*Identificador de horario de verano. Cuando se implementa el horario de verano, tm_isdst es positivo. Sin horario de verano, tm_isdst es 0; cuando la situación es desconocida, Tm_isdst() es negativo. */
};
#define _TM_DEFINED
#endif
El estándar ANSI C dice que esta vez se expresa usando la estructura tm como un éxito Tiempo de uso.
La hora del calendario está representada por el tipo de datos time_t. La hora representada por time_t es el número de segundos a partir de un determinado momento (por ejemplo: 1970 65438 1 de octubre: 00: 00). En time.h, también podemos ver que time_t es un entero largo:
#ifndef _TIME_T_DEFINED
typedef long time _ t /*time value*/
<; p>#define _TIME_T_DEFINED /*Evita definir time_t */#endif
Es posible que estés confundido: dado que time_t es en realidad un entero largo, entonces, desde un cierto punto en el tiempo (generalmente ¿Qué debo hacer si el número de segundos (es decir, el tiempo del calendario) hasta ese momento excede el rango de números que se pueden representar mediante un número entero largo? Para valores del tipo de datos time_t, la hora representada no puede ser posterior a 65438 18, 19:08, 2038 14:07. Para representar tiempos más largos, algunos proveedores de compiladores han introducido números enteros de 64 bits o incluso más largos para ahorrar tiempo en el calendario. Por ejemplo, Microsoft usa el tipo de datos __time64_t para guardar la hora del calendario en Visual C y obtiene la hora del calendario a través de la función _time64() (en lugar de usar la función time() de 32 bits), de modo que el 1 de enero de 3001 0: Se pueden guardar las 00:00 (No incluido
En el archivo de encabezado de time.h, también podemos ver algunas funciones, todas las cuales usan time_t como tipo de parámetro o tipo de valor de retorno:
doble difftime(tiempo _ t tiempo 1, tiempo _ t tiempo 0);
tiempo _ t mktime(struct TM * tiempo ptr);
tiempo _ t tiempo( tiempo _ t * temporizador);
char * ASC tiempo(const struct TM * tiempo ptr
char * ctime(const tiempo _ t * temporizador
);Además, time.h también proporciona dos funciones diferentes para convertir la hora del calendario (un número entero representado por time_t) al formato de hora tm que normalmente vemos y que muestra año, mes, día, minutos y segundos respectivamente:
struct TM * hora GM(const time _ t * timer);
struct TM * hora local(const time _ t * timer);
Consultando MSDN, podemos saber que Microsoft C El valor del punto de tiempo en /C 7.0 (el valor del objeto time_t) es el número de segundos desde el 31 de febrero de 189965438 hasta este momento, mientras que otras versiones de Microsoft C/C y todas las diferentes Las versiones de Visual C comienzan a contar desde 60
4. Funciones relacionadas con fecha y hora y sus aplicaciones
En esta sección, le mostraré cómo usar las funciones declaradas en tiempo.h para manipular la hora. Estas operaciones incluyen obtener la hora actual, calcular intervalos de tiempo, mostrar la hora en diferentes formas, etc.
4.1 Obtener la hora del calendario
Podemos obtener la hora del calendario. la función Time() Su prototipo es: Time_t Time(Time_t * timer);
Si se ha declarado el parámetro temporizador, la hora actual del calendario se puede devolver desde el parámetro temporizador, o la hora actual del calendario. se puede devolver a través del valor de retorno, es decir, el número de segundos desde un determinado momento (por ejemplo: 1970 1,00 0,00) hasta la hora actual.
Si este parámetro es nulo, la función solo devolverá la hora actual del calendario a través del valor de retorno, como el siguiente ejemplo muestra la hora actual del calendario:
#Contiene "time.h"
#Contiene "stdio.h"
int main(void)
{
struct tm * ptr
time _ t lt
lt = time (NUL);
printf("La hora actual del calendario es d\n ", lt;
Return 0; >
}
Los resultados de la operación están relacionados con el momento en ese momento. El resultado de mi operación en ese momento fue:
La hora del calendario actual es 1122707619
donde 112270719 es la hora del calendario cuando ejecuté el programa. Es decir, el número de segundos desde el 1 de octubre de 1970, 0:00, 0:00.
4.2 Fecha y hora de compra
La fecha y hora aquí mencionadas son lo que solemos llamar año, mes, día, hora, minuto, segundo y otra información. De la Sección 2, ya sabemos que toda esta información se almacena en una estructura llamada tm, entonces, ¿cómo usar la estructura tm para guardar una hora del calendario como un objeto?
Las funciones que se pueden utilizar son gmtime() y localtime(). Los prototipos de estas dos funciones son:
struct TM * GM time(const time _ t * timer). ;
struct TM * hora local(const time _ t * timer);
La función gmtime() convierte la hora del calendario a hora estándar universal (GMT) y devuelve una estructura tm a guardar La hora y la función localtime() convierte la hora del calendario a hora local. Por ejemplo, la hora UTC obtenida usando la función gmtime() son las 7:00 del 30 de julio de 2005. Entonces, la hora local obtenida usando la función localtime() en China será 8 horas más tarde que la UTC, es decir, julio. 2005. El día 30 eran 65.438 a las 08:20 horas. Aquí tienes un ejemplo:
#Contiene "time.h"
#Contiene "stdio.h"
int main(void)
{
struct tm * local
hora _ t t
t = hora (NUL); t);
printf("La hora local es: d\n ",Local- gt;TM_hour);
local=gmtime. t);
printf("La hora UTC es: d\n ", local- gt; TM _ hora
Devuelve 0; /p>
El resultado de la ejecución es:
La hora local es: 15
La hora UTC es: 7
4.3 Formato de hora fija
Podemos mostrar la hora en un formato fijo a través de la función asctime() y la función ctime(). Los valores de retorno de ambas funciones son cadenas char *. El formato de hora devuelto es:
Día, mes, día, hora: minuto: segundo año\n\0
Por ejemplo: miércoles 02 de enero 02:03:55 1980\n \0
Donde \n es un carácter de nueva línea y \0 es un carácter nulo, que indica el final de la cadena.
Los siguientes son los prototipos de las dos funciones:
char * ASC time(const struct TM * time ptr);
char * ctime(const time _ t * timer);< /p >
Entre ellos, la función asctime() genera una cadena de formato fijo para guardar información de tiempo a través de la estructura tm, mientras que ctime() genera una cadena de tiempo a través del tiempo del calendario. En este caso, la función asctime() solo necesita completar los campos en el objeto de estructura tm en la posición correspondiente de la cadena de tiempo, mientras que la función ctime() necesita hacer referencia a la configuración de la hora local y convertir la hora del calendario a local. tiempo y luego generar la cadena de formato. A continuación, si t es una variable time_t no vacía, entonces:
printf(ctime( amp; t));
Equivalente a:
struct tm; * ptr
ptr=hora local. t);
printf(ASC time(ptr));
Entonces, los resultados de salida de las dos declaraciones printf en el siguiente programa son diferentes (a menos que configure la zona horaria local a la zona horaria universal de la hora estándar):
#Contiene "time.h"
#Contiene "stdio.h"
int main(void)
{
struct tm * ptr
tiempo _ t lt
lt = tiempo (NUL
); ptr = gmtime (lt;);
printf(hora ASC(ptr));
printf(ctime(lt;));
Devuelve 0;
}
Resultados de la ejecución:
Sábado, 30 de julio de 2005 08:43:03
Sábado, 30 de julio de 2005 16 :43:03
4.4 Formato de hora personalizado
Podemos usar la función strftime() para formatear la hora que queramos. Su prototipo es el siguiente:
size_t strftime(
char *strDest,
size_t maxsize,
const char *format, < /p >
const struct tm *timeptr
);
Podemos poner la información de tiempo guardada en timeptr en la cadena apuntada por strtest de acuerdo con el comando de formato que apunta a la cadena. , strtest puede almacenar hasta caracteres de tamaño máximo. Esta función devuelve el número de caracteres de la cadena a la que apunta strDest.
El funcionamiento de la función strftime() es algo similar a sprintf(): reconoce el conjunto de comandos de formato que comienza con un signo de porcentaje () y coloca el resultado del formato de impresión en una cadena. El comando de formato explica la representación exacta de diversa información de fecha y hora en la cadena strDest. Los demás caracteres de la cadena de formato se colocan en la cadena tal cual. Los comandos de formato se enumeran a continuación. Distinguen entre mayúsculas y minúsculas.
Abreviatura del día de la semana
Nombre completo del día de la semana.
B abreviatura de minutos del mes
Nombre completo del mes B
C serie temporal de fechas estándar
Los dos últimos dígitos del año ¿El número C
d representa qué día del mes en notación decimal?
DMes/Día/Año
eEn un campo de dos caracteres, ¿qué día del mes se representa en notación decimal?
FYaño-Mes-Día
gLos dos últimos dígitos del año, utilizando el año semanal.
G año, usando el año semanal
h nombre corto del mes
H Reloj de 24 horas
I 12 horas
p>
j ¿Qué día del año se expresa en decimal?
mMes decimal
M minutos en tiempo decimal
nCarácter de nueva línea
pLa visualización equivalente de AM o PM local.
r 12 horas
R Muestra horas y minutos: hh: mm.
S Segundos fraccionarios
tCarácter de tabulación horizontal
tVisualización en minutos y segundos: hh:mm:ss.
¿Qué día de la semana es lunes, el primer día (valores del 0 al 6, el lunes es 0)?
¿El domingo es el primer día de la semana del año (valores del 0 al 53)?
VEl número de semana de cada año, utilizando el año basado en semanas.
wEl día de la semana (el rango de valores es de 0 a 6, el domingo es 0)
WEl número de la semana de cada año, el lunes es el primer día (0 a 6 53 )
x cadena de fecha estándar
x serie temporal estándar
y año decimal sin siglo (valores de 0 a 99)
Y año decimal con parte del siglo
z, nombre de la zona horaria Z o el carácter nulo si no se puede obtener el nombre de la zona horaria.
Símbolo de porcentaje
Si desea mostrar qué hora es ahora y mostrar 12 horas, como el siguiente programa:
#Include "time.h"
#Contiene "stdio.h"
int main(void)
{
struct tm * ptr
time_t lt
String[80];
lt = hora (NUL);
ptr = hora local(lt;);
strftime(str, 100, "Ahora soy p", ptr
printf(str);
Return 0; /p>
Los resultados de ejecución son los siguientes:
Son las 4 p.m.
El siguiente programa muestra la fecha de finalización actual:
# include ltstdio .h gt
# include lttime.h gt
Gerente general no válido (no válido)
{
struct tm * newtime
char tmpbuf[128];
hora _ t lt 1;
hora(lt1);
nueva hora = hora local(lt ; 1);
strftime(tmpbuf, 128, "Hoy es el désimo día A del año Y, B,\n ", nueva hora);
printf(tmpbuf);
p>}
Resultados de la ejecución:
Hoy es sábado 30 de julio de 2005.
4.5 Calcular la duración de la duración
En aplicaciones prácticas, a veces es necesario calcular la duración de un evento, como calcular la velocidad de escritura.
En la sección de cronometraje de la parte 1, he dado un ejemplo utilizando funciones de reloj. La función Clock() puede tener una precisión de milisegundos. Al mismo tiempo, también podemos usar la función difftime(), pero solo puede tener una precisión de segundos. La función se define de la siguiente manera:
double difftime(time_t time 1, time_t time 0);
Aunque el intervalo de tiempo en segundos devuelto por esta función es de tipo doble, esto no no significa que el tiempo tenga la misma precisión que el doble, lo cual se siente en sus argumentos (time_t se calcula en segundos). Por ejemplo, el siguiente programa:
#Contiene "time.h"
#Contiene "stdio.h"
#Contiene "stdlib.h"< / p>
int main(void)
{
time_t comienza, termina;
start=time(NUL);
System("pausa");
end = time (NUL);
printf("La pausa tomó f segundos.\n ", difftime(end, start)) ; // lt;-
System("pause");
Return 0;
}
Los resultados de la ejecución son los siguientes siguiente:
p>
Por favor presione cualquier tecla para continuar...
La pausa tomó 2.000000 segundos.
Por favor presiona cualquier tecla para continuar...
Como puedes imaginar, el tiempo de pausa no es una coincidencia de 2 segundos. De hecho, si usa el programa anterior con "//
printf("La pausa tomó f segundos.\n ", end-start);
el resultado de la ejecución es el Lo mismo.
4.6 Descomponer el tiempo en tiempo calendario
El tiempo descompuesto mencionado aquí es una estructura de tiempo guardada en unidades de año, mes, día, hora, minuto y segundo. / estructura tm en C. Podemos usar la función mktime() para convertir el tiempo representado por la estructura tm en tiempo calendario. El prototipo de la función es el siguiente:
time _ t mktime(struct TM * time. ptr);
p>El valor de retorno es el tiempo del calendario convertido. De esta manera, primero podemos hacer un tiempo de descomposición y luego operar con este tiempo.
El siguiente ejemplo puede calcular la fecha de la semana de julio de 1997:
#Contiene "time.h"
#Contiene "stdio.h"
# Contiene " stdlib.h "
int main(void)
{
struct TM t;
Hora del día;
p>t TM_año = 1997-1900;
t TM_mon = 6
t . p>t . TM _ hora = 0
t .TM_min = 0
t . = 0;
t_of_day = mktime(amp;t);
printf(ctime(amp;t_of_day);
Devuelve 0;
}
Ejecutar resultado:
Martes 06 5438 0 00:00:06 5438 0 1 997
Ahora tenga en cuenta que con la función mktime(), ¿Podemos operar en cualquier momento antes de ahora? ¿Puedes usar este método para calcular el día de la semana en agosto de 1945? La respuesta es no, porque esta vez es 1970 65438 10 antes del mes 1, por lo que en la mayoría de los compiladores, aunque es así. El programa se puede compilar, su tiempo de ejecución finalizará de forma anormal.