Función ascTime en lenguaje C

Los datos de tiempo se calculan desde segundos desde 00:00:00 UTC el 1 de enero de 1970 GMT o UNIX Time. Para usar estos datos en un formato legible por humanos, debe convertir la hora UNIX a una fecha de tiempo y luego a una cadena.

En esto Pista de Linux Artículo, explicaremos cómo usar ascTime () Para recuperar los datos de tiempo del calendario del sistema y convertirlos en una cadena. Exploraremos la descripción teórica de la estructura de estos datos TM, la sintaxis de la función y sus argumentos de entrada y salida junto con los tipos de datos que cada uno de ellos admite. Luego implementaremos el uso de esta función con ejemplos prácticos utilizando fragmentos e imágenes de código.

Sintaxis de función ascTime () en lenguaje C

char * str ascTime (const struct tm * tm_ptr);

Descripción de la función ascTime () en el idioma C

El ascTime () la función recupera la información de Struct TM que apunta por el *tm_ptr puntero, lo convierte en una cadena y devuelve su puntero en *str.

El formato que devuelve esta función en la cadena de salida es el siguiente:

"Www mmm dd hh: mm: ss yyyy \ n \ 0"

Ambos días y meses están representados por las tres primeras letras de sus nombres. Las fechas están representadas por dos dígitos para los días y meses y cuatro dígitos para el año. La cadena correspondiente a stri contiene un personaje especial \ n \ 0 al final.

El ascTime () la función y sus variables se definen en el "tiempo.encabezado. Para usarlos, tenemos que incluirlos en nuestro ".C "o".archivo h "de la siguiente manera:

#incluir

Cómo obtener la hora local en formato de cadena con la función ascTime () en el idioma C

En este ejemplo, le mostraremos paso a paso sobre cómo usar el ascTime () función para obtener los datos de tiempo de UNIX y tiempo local en la estructura TM y luego convertirlo en una cadena de caracteres legibles por humanos.

Como explicamos en la introducción, el tiempo del sistema se calcula a partir del tiempo UNIX. Por lo tanto, tenemos que obtener este tiempo primero con la función Time () en TIME_T.

En el siguiente fragmento, Time () obtiene el tiempo de Unix en U_time y lo imprime a la consola de comando:

#incluir
#incluir
vacío principal()

Time_tu_time;
U_time = time (nulo);
printf ("Tiempo unix: %ld \ n", u_time);

La siguiente imagen muestra la hora UNIX que se devuelve en U_time.

Una vez que obtenemos el tiempo de Unix, necesitamos convertir estos datos a un tiempo local o GMT y almacenarlos en la estructura entera, TM.

Cada entero en esta estructura representa segundos, minutos, horas, días, etc. Más tarde, daremos una descripción más detallada de las variables contenidas en esta estructura y cómo puede acceder a cada uno de ellos.

Los datos de la estructura TM pueden ser la hora local en la que obtiene con hora local() o el tiempo GMT con gmtime ().

Ambas funciones tienen el tiempo de Unix obtenido con U_time como argumento de entrada y devuelve el puntero TM_PTR de TM, que debemos definir de antemano como se muestra en lo siguiente:

#incluir
#incluir
vacío principal()

…
struct tm *tm_ptr; // Defina TM_PTR como un puntero a TM
…

Es importante tener en cuenta que tanto el tiempo de Unix en U_time y los datos de TM se actualizan cada vez que se llaman una de las funciones que recuperan estos datos. De lo contrario, los datos de la última llamada permanecen almacenados en sus variables.

En el siguiente fragmento de código, vemos cómo recuperar los datos de tiempo local en la estructura TM utilizando la función localTime (). Cuando llama a esta función, debe pasar el tiempo de Unix como argumento de entrada y el puntero a TM como argumento de salida.

tm_ptr = localtime (& u_time);

De esta manera, ya convirtimos el tiempo de Unix a la hora local y lo almacenamos en la estructura TM. Solo necesitamos convertir estos datos en una cadena con ascTime ().

En el siguiente fragmento, vemos el código para obtener el tiempo de Unix. Calcule estos datos y guárdelo en tm struct. Luego, usamos ascTime () para convertir los enteros de la estructura que es apunta por *tm_ptr a las cuerdas.

Esta función devuelve la cadena que es apunta por *str_ptr En su argumento de salida.

Finalmente, emitimos la cadena obtenida a la consola de comando usando printf ().

#incluir
#incluir
vacío principal()

Time_tu_time; // Defina U_Time como salida de tiempo ()
const char*str_ptr; // Defina el puntero de la cadena
struct tm *tm_ptr; // Defina TM_PTR como un puntero a TM
U_time = time (nulo); // Obtenemos el tiempo UTC en U_Time
tm_ptr = localtime (& u_time); // Obtenemos la hora local en TM
str_ptr = ascTime (tm_ptr); // Convertir TM a cadena
printf ("La hora local es: %s \ n", str_ptr);

La siguiente imagen muestra el resultado de este código:

El Estructura tm

El TM estructura y el TIME_T y reloj_t Las variables son estructuras predefinidas y tipos de datos en el "tiempo.h "encabezado y se utilizan para almacenar los resultados que devuelven algunas de las funciones definidas allí.

Veamos ahora la estructura del entero TM y los nombres de las variables individuales que la componen:

structtm
inttm_sec; // segundos (0-61)
inttm_min; // minutos (0-59)
inttm_hour; // horas (0-23)
inttm_mday; // Día (1-31)
inttm_mon; // mes (0-11)
inttm_year; // años desde 1970
inttm_wday; // día de semana (0-6; domingo = 0)
inttm_yday; // Día del año (0-365)
inttm_isdst; // Tiempo de verano 1 = sí; 0 = no; -1 = indefinido
;

Conclusión

En esto Pista de Linux Artículo, explicamos cómo obtener el tiempo del sistema Unix y convertirlo en una cadena de calendario con ascTime () paso a paso. También explicamos brevemente las funciones adicionales que se necesitan para procesar y recuperar estos datos, así como cómo manejar los datos de TM y TIME. Esperamos que hayas encontrado este artículo útil. Para más Pista de Linux Artículos sobre el idioma C, use el motor de búsqueda en nuestro sitio web.