Programmiersprache C/C++

Datum und Zeit

Für den Umgang mit der Zeit existieren zwei Mechanismen: Zum Umgang mit Datum und Zeit werden über die Header-Datei time.h folgende Datentypen bereitgestellt:

time

  #include <time.h>

  time_t time(time_t *t);
Liefert das aktuelle Datum und die aktuelle Uhrzeit.
time setzt die übergebene Variable t auf die Anzahl der Sekunden, die seit dem 1. Januar 1970, 00:00:00 (Greenwich Mean Time) verstrichen sind.
Als Aufrufparameter kann auch der NULL-Zeiger übergeben werden.

Bemerkung:
Datum und Uhrzeit sind nur dann korrekt, wenn der Systemadministrator für eine korrekte Einstellung der Systemuhr gesorgt hat.
Die Angaben werden beeinflußt durch die Angabe der Zeitzone und der Festlegung zur Verwendung der Sommerzeit.
Die Sommerzeit wird typischerweise nach den in den USA geltenden Regeln bestimmt.

Rückgabewert.
time liefert die Anzahl der seit dem 1.1.1970 verstrichenen Sekunden zurück.

Beispiel: 

  #include <time.h>
  #include <stdio.h>

  int main(void)
  {
    time_t t;

    t = time(NULL);            /*  oder   time(&t);    */
    printf("Die Anzahl der Sekunden seit dem 1. Januar 1970 : %ld", t);

    return 0;
  }

localtime

  #include <time.h>

  struct tm *localtime(const time_t *t);
Konvertiert Datum und Uhrzeit vom Typ time_t in eine Struktur des Typs tm.
localtime übernimmt die Adresse eines Wertes, wie er z.B. durch time geliefert wird, und gibt einen Zeiger auf die Struktur des Typs tm zurück.
localtime berücksichtigt bei der Konvertierung Zeitzonen und Sommerzeit.
Die Einstellung von Zeitzone und Sommerzeit kann über mit Hilfe der Funktion tzset verändert werden.

Rückgabewert:
localtime liefert einen Zeiger auf eine statische Struktur, die die einzelnen Zeitangaben enthält. Die Struktur wird durch jeden Aufruf dieser Funktionen erneut gesetzt. 

  #include <time.h>
  #include <stdio.h>

  int main(void)
  {
    time_t t;
    struct tm *ts;

    t = time(NULL);
    ts = localtime(&t);
    printf("Aktuelle Zeit: %s", asctime(ts));

    return 0;
  }

ctime

  #include <time.h>

  char *ctime(const time_t *time);
Konvertiert Datum und Uhrzeit in eine Zeichenkette.
ctime erwartet einen Zeiger auf Datum und Uhrzeit des Systems in der Form, wie er von der Funktion time geliefert wird.
ctime liefert eine Zeichenkette mit 26 Zeichen, die mit einem Zeilenvorschub und einem Nullzeichen abgeschlossen ist.
Beispiel: 
  Sat Feb 17 19:31:26 1996\n\0
Alle Felder der Zeichenkette haben eine konstante Länge.

Die globale long-Variable _timezone enthält den Unterschied zwischen der lokalen Zeit und der Greenwich Mean Time (GMT) in Sekunden (für MEZ ist _timezone -1*60*60). Die globale Variable _daylight darf nur dann auf einen Wert ungleich Null gesetzt werden, wenn die Standardkonvertierung der USA für Sommer- und Winterzeit angewendet werden soll. Diese Variablen werden nicht vom einem Benutzerprogramm direkt, sondern von der Funkton tzset gesetzt Rückgabewert:
ctime liefert einen Zeiger auf eine statischen Zeichenkette zurück, der Datum und Uhrzeit enthält.

Beispiel: 

  #include <stdio.h>
  #include <time.h>

  int main(void)
  {
    time_t t;

    time(&t);
    printf("%s", ctime(&t));

    return 0;
  }

asctime

  #include <time.h>

  char *asctime(const struct tm *ts);
Konvertiert Datum und Uhrzeit in eine Zeichenkette.
asctime konvertiert eine Zeitangabe, die als Struktur des Typs tm in ts gespeichert ist, in eine Zeichenkette mit 26 Zeichen, deren Format am folgenden Beispiel demonstriert wird: 
  Sat Feb 17 19:31:26 1996\n\0
asctime und ctime liefern gleichartige Ergebnisse. Beide Funktionen unterscheiden sich nur durch den Datentyp des Aufrufparameters.

Rückgabewert:
asctime liefert einen Zeiger auf eine Zeichenkette zurück, die Datum und Uhrzeit enthält.

mktime

  #include <time.h>

  time_t mktime(struct tm *t);
Konvertiert Zeitangaben, die in einer Struktur des Typs tm vorliegen, in das interne Format vom Typ .

Die Eingabewerte der Felder tm_sec, tm_min, tm_hour, tm_mday und tm_mon sind nicht auf den durch die tm-Struktur festgelegten Bereich beschränkt. Befinden sich die Werte nicht im korrekten Bereich, so werden sie angepaßt.
Die Werte der Felder tm_wday und tm_yday werden nach der Anpassung der anderen Felder berechnet.
Kann die Kalenderzeit nicht dargestellt werden, so liefert mktime den Wert -1 zurück.

Die zulässige Bereich für die Kalenderzeit liegt zwischen dem 1. Januar 1970 00:00:00 und dem 19. Januar 2038 03:14:07.

gmtime

  #include <time.h>

  struct tm *gmtime(const time_t *t);
Rechnet Datum und Uhrzeit in die Greenwich Mean Time (GMT) um.
gmtime erwartet die Adresse eines Wertes, so wie er z.B. von time zurückgeliefert wird, und liefert einen Zeiger auf eine Struktur vom Typ tm. Rückgabewert:
gmtime liefert einen Zeiger auf eine Struktur des Typs tm.

difftime

  #include <time.h>

  double difftime(time_t t1, time_t t2);
Rückgabewert:
Differenz zwischen zwei Zeitwerten in Sekunden.

clock

  #include <time.h>

  clock_t clock(void);
Rückgabewert:
Verbrauchte CPU-Zeit seit dem Programmstart in Ticks.

Bemerkung:
Wird die verbrauche Zeit in Sekunden benötigt, so muß der durch clock ermittelte Wert durch CLOCK_PER_SEC dividiert werden.

Beispiel: 

  #include <stdio.h>
  #include <time.h>

  int main(void)
  {
    char *wday[] = { "Sonntag", "Montag", "Dienstag", "Mittwoch",
         "Donnerstag", "Freitag", "Samstag", "???" };

    struct tm ts;
    int year, month, day;

    printf("Jahr:  ");   scanf("%d", &year);
    printf("Monat: ");   scanf("%d", &month);
    printf("Tag:   ");   scanf("%d", &day);

    ts.tm_year = year - 1900;
    ts.tm_mon  = month - 1;
    ts.tm_mday = day;

    ts.tm_hour = 0;
    ts.tm_min  = 0;
    ts.tm_sec  = 1;
    ts.tm_isdst = -1;

    if ( mktime(&ts) == -1 )
      ts.tm_wday = 7;

    printf("Dieser Tag ist ein %s\n", wday[ts.tm_wday]);

    return 0;
  }


  #include <stdio.h>
  #include <stdlib.h>
  #include <time.h>

  int main(void)
  {
    char *tz1 = "TZ=NFT-1DFT";
    char *tz2 = "TZ=PST8PDT"; 
    time_t t;
    struct tm *gmt, *pst, *nft;

    t = time(NULL);

    putenv(tz1);
    tzset();

    nft = localtime(&t);
    printf("Middle European Time : %s", asctime(nft));

    putenv(tz2);
    tzset();

    pst = localtime(&t);
    printf("Pacific time         : %s", asctime(pst));

    gmt = gmtime(&t);
    printf("Greenwich time       : %s", asctime(gmt));
  
    return 0;
  }
Programmausgabe: Middle European Time : Sat Feb 17 20:24:07 1996 Pacific time : Sat Feb 17 11:24:07 1996 Greenwich time : Sat Feb 17 19:24:07 1996

strftime

  #include <time.h>
  size_t strftime(char *s, size_t maxsize, const char *fmt,
                  const struct tm *t);
Formatiert die Uhrzeit für die Ausgabe.
strftime formatiert die Uhrzeit im Argument t und gibt sie in die Zeichenkette aus, auf die das Argument s zeigt.
Bei der Formatierung werden die in fmt enthaltenen Formatieranweisungen angewandt. Der Format-String besteht aus null oder mehr Format-Deskriptoren und normalen Zeichen.
Wie bei printf besteht eine Anweisung aus dem Zeichen %, gefolgt von dem Zeichen für das einzusetzende Format. Alle normalen Zeichen werden unverändert kopiert. Es werden maximal maxsize Zeichen nach s geschrieben.

Rückgabewert:
strftime liefert die Anzahl der Zeichen zurück, die nach s geschrieben wurden. Ist die Anzahl der benötigten Zeichen größer als maxsize, so wird 0 zurückgeliefert.

Format-Deskriptoren 

  %%    %-Zeichen
  %a    Abgekürzter Wochentagname
  %A    Vollständiger Wochentagname
  %b    Abgekürzter Monatsname
  %B    Vollständiger Monatsname
  %c    Datum und Uhrzeit
  %d    Zwei Ziffern für den Tag im Monat (01 - 31)
  %H    Zwei Ziffern für die Stunde (00 - 23)
  %I    Zwei Ziffern für die Stunde (01 - 12)
  %j    Drei Ziffern für den Tag im Jahr (001 - 366)
  %m    Zwei Ziffern für den Monat als Dezimalzahl (1 - 12)
  %M    Zwei Ziffern für die Minute (00 - 59)
  %p    AM oder PM (vormittags oder nachmittags)
  %S    Zwei Ziffern für die Sekunde (00 - 59)
  %U    Zwei Ziffern für die Wochenzahl, wobei der Sonntag den
        ersten Tag der Woche darstellt (00 - 53)
  %w    Wochentag, wobei 0 dem Sonntag entspricht (0 - 6)
  %W    Zwei Ziffern für die Wochenzahl, wobei der Montag den
        ersten Tag der Woche darstellt (00 - 53)
  %x    Datum
  %X    Uhrzeit
  %y    Zwei Ziffern für das Jahr ohne Jahrhundert (00 - 99)
  %Y    Jahr mit Jahrhundert 
  %Z    Name der Zeitzone oder keine Zeichen, wenn keine Zeitzone
        festgelegt ist

Beispiel: 

  #include <stdio.h>
  #include <string.h>
  #include <time.h>

  #define N 80

  int main(void)
  {
    time_t t;
    struct tm ts;
    char str[N];

    ts.tm_sec    = 0;      /* Sekunden */
    ts.tm_min    = 30;     /* Minuten */
    ts.tm_hour   = 16;     /* Stunden */
    ts.tm_mday   = 29;     /* Tag im Monat  */
    ts.tm_mon    = 1;      /* Monat - 1*/
    ts.tm_year   = 97;     /* Jahr - 1900 */
    ts.tm_wday   = 4;      /* Wochentag  */
    ts.tm_yday   = 0;      /* laufender Tag im Jahr - nicht verw. von asctime */
    ts.tm_isdst  = 0;      /* Sommerzeit ? - nicht verwendet von asctime */

    t = mktime(&ts);
    printf("%s", ctime(&t));
    printf("%s", asctime(&ts));
    strftime(str, N, "%j : %A, %d.%B.%Y, %H:%M", &ts);
    printf("%s\n", str);

    return 0;
  }
Testergebnis: 
  Sat Mar 01 16:30:00 1997
  Sat Mar 01 16:30:00 1997
  060 : Saturday, March 01 1997, 16:30
Der 29.02.1997 wird korrigiert auf den 01.03.1997

Zurück zum Menü
Zurück zur vorigen Seite Weiter zur nächsten Seite
P. Böhme, 17.03.1996