ASCTIME -funksjon på C -språk

Tidsdata er beregnet fra sekunder siden 00:00:00 UTC 1. januar 1970 GMT eller Unix Time. For å bruke disse dataene i et menneskelig lesbart format, må du konvertere UNIX -tiden til en tidsdato og deretter til en streng.

I dette Linux hint Artikkel, vi vil forklare hvordan vi skal bruke ASCTIME () For å hente tidsdataene fra systemkalenderen og konvertere dem til en streng. Vi vil utforske den teoretiske beskrivelsen av strukturen til denne data TM, syntaksen til funksjonen og dens inngangs- og utgangsargumenter sammen med datatypene som hver av dem støtter. Vi vil deretter implementere bruken av denne funksjonen med praktiske eksempler ved hjelp av kodebiter og bilder.

Asctime () funksjonssyntaks på C -språk

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

Beskrivelse av ASCTime () -funksjonen på C -språket

De ASCTIME () funksjon henter informasjonen fra struct tm som er pekt på av *TM_PTR pekeren, konverterer den til en streng og returnerer pekeren inn *Str.

Formatet som returneres av denne funksjonen i utgangsstrengen er som følger:

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

Både dager og måneder er representert med de tre første bokstavene i navnene deres. Datoene er representert med to sifre for dagene og månedene og fire sifre for året. Strengen som tilsvarer str inneholder et spesielt tegn \ n \ 0 på slutten.

De ASCTIME () Funksjon og variabler er definert i “tiden.h ”header. For å bruke dem, må vi inkludere dem i ".C ”eller“.H ”-filen som følger:

#inkludere

Hvordan få lokal tid i strengformat med ASCTime () -funksjonen på C -språket

I dette eksemplet vil vi vise deg trinn for å bruke hvordan du bruker ASCTIME () Funksjon for å få Unix-tid og lokale tidsdata i TM-strukturen og konvertere dem deretter til en rekke menneskelige lesbare karakterer.

Som vi forklarte i innledningen, beregnes systemtiden ut fra UNIX -tiden. Derfor må vi få denne gangen først med tiden () -funksjonen i time_t.

I det følgende utdraget får tiden () Unix -tiden i U_time og skriver den ut til kommandokonsollen:

#inkludere
#inkludere
tomrom ()

time_tu_time;
U_time = tid (null);
printf ("Unix Time: %ld \ n", u_time);

Følgende bilde viser Unix -tiden som returneres i U_time.

Når vi har fått tiden fra UNIX, må vi konvertere disse dataene til en lokal eller GMT -tid og lagre dem i heltallstrukturen, tm.

Hvert heltall i denne strukturen representerer sekunder, minutter, timer, dager osv. Senere vil vi gi en mer detaljert beskrivelse av variablene i denne strukturen og hvordan du kan få tilgang til hver av dem.

Dataene fra TM -strukturen kan være den lokale tiden du får med lokal tid() eller GMT -tiden med gmtime ().

Begge funksjonene har Unix -tiden oppnådd med U_time Som inngangsargument og returner pekeren TM_PTR av tm, som vi må definere på forhånd som vist i følgende:

#inkludere
#inkludere
tomrom ()

..
struct tm *tm_ptr; // Definer TM_PTR som en peker til TM
..

Det er viktig å merke seg at både Unix -tiden i U_time og TM -dataene oppdateres hver gang en av funksjonene som henter disse dataene kalles. Ellers forblir dataene fra den siste samtalen lagret i deres variabler.

I følgende kodebit ser vi hvordan du kan hente de lokale tidsdataene i TM -strukturen ved å bruke lokal () -funksjonen. Når du kaller denne funksjonen, må du passere tiden fra UNIX som inngangsargumentet og pekeren til TM som utgangsargument.

TM_PTR = Lokaletid (& u_time);

På denne måten konverterte vi allerede tiden fra UNIX til lokal tid og lagret den i TM -strukturen. Vi trenger bare å konvertere disse dataene til en streng med ASCTIME ().

I det følgende utdraget ser vi koden for å få tid fra UNIX. Beregn disse dataene og lagre dem i TM -struktur. Deretter bruker vi AscTime () for å konvertere heltallene til strukturen som er pekt på av *TM_PTR til strenger.

Denne funksjonen returnerer strengen som er pekt på av *STR_PTR I sitt output -argument.

Til slutt sender vi ut den oppnådde strengen til kommandokonsollen ved hjelp av printf ().

#inkludere
#inkludere
tomrom ()

time_tu_time; // definere u_time som utgang av tid ()
const char*str_ptr; // definere pekeren til strengen
struct tm *tm_ptr; // Definer TM_PTR som en peker til TM
U_time = tid (null); // vi får UTC -tiden i u_time
TM_PTR = Lokaletid (& u_time); // vi får lokal tid i TM
STR_PTR = ASCTIME (TM_PTR); // Konverter TM til streng
printf ("lokal tid er: %s \ n", str_ptr);

Følgende bilde viser resultatet av denne koden:

De Tm struct

De tm struktur og time_t og klokke_t Variabler er forhåndsdefinerte strukturer og datatyper i “TID.H ”header og brukes til å lagre resultatene som returneres av noen av de definerte funksjonene der.

La oss nå se på strukturen til TM -heltallet og navnene på de individuelle variablene som utgjør det:

struktur
Inttm_sec; // sekunder (0-61)
Inttm_min; // minutter (0-59)
INTTM_HOUR; // timer (0-23)
INTTM_MDAY; // dag (1-31)
Inttm_mon; // måned (0-11)
INTTM_YEAR; // år siden 1970
INTTM_WDAY; // ukedag (0-6; søndag = 0)
Inttm_yday; // Årets dag (0-365)
INTTM_ISDST; // Sommertid 1 = Ja; 0 = nei; -1 = udefinert
;

Konklusjon

I dette Linux hint Artikkel, vi forklarte hvordan du får UNIX -systemetiden og konverterer den til en kalenderstreng med ASCTIME () steg for steg. Vi forklarte også kort de tilleggsfunksjonene som er nødvendige for å behandle og hente disse dataene, samt hvordan vi skal håndtere TM- og tidsdata. Vi håper at du fant denne artikkelen nyttig. For mer Linux hint Artikler på C -språket, bruk søkemotoren på nettstedet vårt.