Função de ASCTime em C Linguagem

Os dados do tempo são calculados a partir dos segundos desde 00:00:00 UTC em 1º de janeiro de 1970 GMT ou UNIX Time. Para usar esses dados em um formato legível humano, você deve converter o tempo do Unix em uma data de horário e depois em uma string.

Nisso Linux Dica artigo, explicaremos como usar asctime () Para recuperar os dados do tempo do calendário do sistema e convertê -los em uma string. Exploraremos a descrição teórica da estrutura desses dados, a sintaxe da função e seus argumentos de entrada e saída, juntamente com os tipos de dados que cada um deles suporta. Em seguida, implementaremos o uso dessa função com exemplos práticos usando trechos e imagens de código.

Asctime () função sintaxe na linguagem C

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

Descrição da função Asctime () na linguagem C

O asctime () A função recupera as informações da Struct TM, que é apontada pelo *tm_ptr ponteiro, converte -o em uma corda e retorna seu ponteiro em *str.

O formato que é retornado por esta função na sequência de saída é o seguinte:

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

Ambos os dias e meses são representados pelas três primeiras letras de seus nomes. As datas são representadas por dois dígitos nos dias e meses e quatro dígitos para o ano. A sequência correspondente a str contém um caractere especial \ n \ 0 no final.

O asctime () função e suas variáveis ​​são definidas no “tempo.H ”cabeçalho. Para usá -los, temos que incluí -los em nosso “.C "ou".Arquivo H ”da seguinte maneira:

#incluir

Como obter o horário local no formato de string com a função Asctime () na linguagem C

Neste exemplo, mostraremos a você passo a passo sobre como usar o asctime () Função para obter o tempo Unix e os dados da hora local na estrutura da MT e depois convertê-los em uma série de caracteres legíveis por humanos.

Como explicamos na introdução, o tempo do sistema é calculado a partir do tempo Unix. Portanto, temos que conseguir esse tempo primeiro com a função de tempo () em time_t.

No snippet seguinte, o tempo () recebe o tempo do Unix em U_time e imprime -o para o console de comando:

#incluir
#incluir
void main ()

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

A imagem a seguir exibe o tempo Unix que é devolvido em U_time.

Depois de obtermos o tempo do Unix, precisamos converter esses dados em um tempo local ou GMT e armazená -los na estrutura inteira, tm.

Cada número inteiro nessa estrutura representa segundos, minutos, horas, dias, etc. Mais tarde, daremos uma descrição mais detalhada das variáveis ​​contidas nesta estrutura e como você pode acessar cada uma delas.

Os dados da estrutura da MT podem ser o horário local em que você obtém horário local() ou o tempo de GMT com gmtime ().

Ambas as funções têm o tempo do Unix obtido com U_time como argumento de entrada e retornar o ponteiro tm_ptr de tm, que devemos definir de antemão, conforme mostrado no seguinte:

#incluir
#incluir
void main ()

..
struct tm *tm_ptr; // define tm_ptr como um ponteiro para tm
..

É importante observar que tanto o tempo do Unix em U_time e os dados da TM são atualizados sempre que uma das funções que recuperam esses dados são chamadas. Caso contrário, os dados da última chamada permanecem armazenados em suas variáveis.

No snippet de código a seguir, vemos como recuperar os dados da hora local na estrutura da MT usando a função Localtime (). Quando você chama essa função, você deve passar o tempo do Unix como o argumento de entrada e o ponteiro para a TM como o argumento de saída.

tm_ptr = localTime (& u_time);

Dessa forma, já convertemos o tempo do Unix para a hora local e o armazenamos na estrutura da TM. Precisamos apenas converter esses dados em uma string com asctime ().

No trecho seguinte, vemos o código para obter o tempo do Unix. Calcule esses dados e armazene -os em TM Struct. Em seguida, usamos asctime () para converter os números inteiros da estrutura que é apontado por *tm_ptr para cordas.

Esta função retorna a string que é apontada por *str_ptr em seu argumento de saída.

Finalmente, produzimos a string obtida para o console de comando usando printf ().

#incluir
#incluir
void main ()

time_tu_time; // define u_time como saída do tempo ()
const char*str_ptr; // Defina o ponteiro da corda
struct tm *tm_ptr; // define tm_ptr como um ponteiro para tm
U_time = time (nulo); // Temos o tempo da UTC em U_time
tm_ptr = localTime (& u_time); // Temos a hora local na tm
str_ptr = asctime (tm_ptr); // converte TM em string
printf ("hora local é: %s \ n", str_ptr);

A imagem a seguir mostra o resultado deste código:

O Tm struct

O tm estrutura e o time_t e relógio_t Variáveis ​​são estruturas predefinidas e tipos de dados no “tempo.H ”Cabeçalho e são usados ​​para armazenar os resultados que são retornados por algumas das funções definidas lá.

Vamos agora olhar para a estrutura do número inteiro da MT e os nomes das variáveis ​​individuais que o compõem:

structtm
inttm_sec; // segundos (0-61)
inttm_min; // minutos (0-59)
inttm_hour; // horas (0-23)
inttm_mday; // dia (1-31)
inttm_mon; // mês (0-11)
inttm_year; // anos desde 1970
inttm_wday; // dia da semana (0-6; domingo = 0)
inttm_yday; // Dia do ano (0-365)
inttm_isdst; // Tempo de verão 1 = sim; 0 = não; -1 = indefinido
;

Conclusão

Nisso Linux Dica Artigo, explicamos como obter o tempo do sistema Unix e convertê -lo em uma string de calendário com asctime () passo a passo. Também explicamos brevemente as funções adicionais necessárias para processar e recuperar esses dados, bem como lidar com os dados da MT e Time. Esperamos que você tenha achado este artigo útil. Para mais Linux Dica Artigos sobre o idioma C, use o mecanismo de pesquisa em nosso site.