Algorithmen und Datenstrukturen

| ### Algorithmen & Datenstrukturen Programmieren 1 von Prof. Jürgen Plate

# Überblick der Standard-Bibliotheken

### Standard-Includefiles

`<assert.h>`
  Kontrolle von Variablen
`<ctype.h>`
  Einteilung der Zeichen in Gruppen
`<errno.h>`
  Die Fehlervariable `errno`
`<float.h>`
  Bereichsgrenzen von Gleitkommazahlen
`<limits.h>`
  Bereichsgrenzen von Ganzzahlen
`<locale.h>`
  Konstanten und Funktionen für lokale Gegebenheiten
`<math.h>`
  Mathematische Funktionen
`<setjmp.h>`
  Nichtlokale Sprünge im Programmablauf
`<signal.h>`
  Behandlung externer Ereignisse
`<stdarg.h>`
  Makros zur Verwaltung variabler Argumente (s. o.)
`<stddef.h>`
  Häufig benötigte Konstanten
`<stdio.h>`
  Ein- und Ausgabefunktionen und -makros
`<stdlib.h>`
  Standardfunktionen
`<string.h>`
  String- und Speicherbereichsfunktionen
`<time.h>`
  Funktionen zum Umgang mit Datum und Zeit

### Bibliothek `stddef.h`

`NULL`
  nil-Zeiger, gleichbedeutend mit `0`
`size_t`
  Ergebnistyp von `sizeof`
`ptrdiff_t`
  Ergebnistyp der Differenz zweier Zeiger
`wchar_t`
  Wide character type

### Bibliothek `errno.h`

`errno`
  Globale Variable, wird von vielen Funktionen verwendet, enthält bei Fehler den Fehlercode

### Bibliothek `stdio.h`

#### Bekannte Funktionen

`int putchar(int)`
  liefert Zeichen oder `EOF`, kann Makro sein
`int getchar(void)`
  liefert Zeichen oder `EOF`, kann Makro sein
`int printf(const char *format, ...)`
`int scanf(const char *format, ...)`
  - Adressen als Argumente

#### Dateiverwaltung

- Datenstruktur `FILE`
- `FILE *fopen(const char *filename,const char *modus)` liefert `NULL` bei Fehler
  `"r"`
    Zum Lesen, Datei muß existieren
  `"w"`
    Zum Schreiben, alter Inhalt wird ggf. gelöscht
  `"a"`
    Zum Anhängen, alter Inhalt bleibt ggf. erhalten
  `"r+"`
    Zum Lesen und Schreiben, alter Inhalt bleibt ggf. erhalten, kann überschrieben werden
  `"w+"`
    Zum Lesen und Schreiben, alter Inhalt wird gelöscht
  `"a+"`
    Zum Lesen und Anhängen, geschrieben wird immer am Ende
- Zusatzzeichen `"b"` für Binärdateien
- Zwischen Lesen und Schreiben `fflush()` oder Positionierungsfunktion nötig
- Maximal `FOPEN_MAX` Dateien gleichzeitig geöffnet, maximale Dateinamenlänge `FILENAME_MAX`
- `int fclose(FILE *f)` liefert `0` oder `EOF`
- Zu Beginn geöffnete Dateien: `FILE *const stdin;` und `FILE *const stdout;` und `FILE *const stderr;`
- `FILE *freopen(const char *filename, const char *mode, FILE *stream)` liefert `stream` oder `NULL`
- Verwendung zum Umleiten von `stdin`, `stdout`, `stderr`
- `FILE *tmpfile(void)` öffnet `"w+b"` und löscht nach Programmende
- `char *tmpnam(char s[L_tmpnam])` liefert einen von bis zu `TMP_MAX` verschiedenen temporären Dateinamen nach `s`, `s` darf `NULL` sein
- `int remove(const char *filename)` liefert `0` oder Fehler
- `int rename(const char *oldname, const char *newname)` liefert 0 oder Fehler
- `int fflush(FILE *stream)` liefert `0` oder `EOF`, Stream `NULL` = alle Dateien
- `int setvbuf(FILE *f, char *buf, int mode, size_t size)` liefert `0` oder Fehler; setzt Puffermechanismus auf vollständig (`mode` = `_IOFBF`), zeilenweise (`mode` = `_IOLBF`) oder ungepuffert (`mode` = `_IONBF`) und verwendet `buf` oder bei `buf` = `NULL` einen internen Puffer der Länge `size`
- `void setbuf(FILE *f, char *buf)` wie `(void)setvbuf(f,buf,_IOFBF,BUFSIZ)` oder bei `buf` = `NULL` ungepuffert

#### Ein- und Ausgabe in Dateien

- `int fprintf(FILE *f, const char *format, ...)` wie `printf()`
- `int fscanf(FILE *f, const char *format, ...)` wie `scanf()`
- `int sprintf(char *s, const char *format, ...)` wie `printf()`
- `int sscanf(char *s, const char *format, ...)` wie `scanf()`
- `int putc(int c, FILE *f)` und `int fputc(int c, FILE *f)` wie `putchar()` (`putc()` kann Makro sein)
- `int getc(FILE *f)` und `int fgetc(FILE *f)` wie `getchar()` (`getc()` kann Makro sein)
- `int puts(const char *s)` und `int fputs(const char *s, FILE *f)` liefert ok oder `EOF` (`puts()` ergänzt Zeilenende)
- `char *gets(char *s)` liefert s oder bei EoF oder Fehler `NULL`, liest beliebig viele Zeichen bis Zeilenende nach `s`, legt statt des `\n` ein Nullbyte ab
- `char *fgets(char *s, int n, FILE *f)` liefert s oder bei EoF oder Fehler `NULL`, liest maximal n-1 Zeichen nach `s`, hört aber vorzeitig nach `\n` auf (das noch abgelegt wird), und hängt Nullbyte an
- `int ungetc(int c, FILE *f)` liefert c oder EOF, stellt ein Zeichen zurück
- `size_t fread(void *p, size_t size, size_t count, FILE *f)`
- `size_t fwrite(void *p, size_t size, size_t count, FILE *f)`

#### Positionierung in Dateien

- `int fseek(FILE *f, long offset, int origin)` positioniert um `offset` Zeichen relativ zum Dateianfang (`origin` = `SEEK_SET`), zum Dateiende (`origin` = `SEEK_END`) oder zur aktuellen Position (`origin` = `SEEK_CUR`)
- `long ftell(FILE *f)` liefert aktuelle Position oder `-1L`
- `void rewind(FILE *f)` positioniert am Dateianfang und löscht Fehlerstatus
- `int fgetpos(FILE *f, fpos_t *p)` liefert `0` oder Fehler, legt Position in `*p` ab
- `int fsetpos(FILE *f, const fpos_t *p)` liefert `0` oder Fehler, setzt Position aus `*p`

#### Fehlerbehandlung

- Wenn die letzte Standardein-/-ausgabefunktion eine Fehlerbedingung geliefert hat, enthält `int errno` (definiert in `<errno.h>`) eine Fehlernummer
- `void clearerr(FILE *f)` löscht Fehlerstatus
- `int feof(FILE *f)` liefert Zahl bei EoF oder `0`
- `int ferror(FILE *f)` liefert Zahl bei Fehlerstatus oder `0`
- `void perror(const char *s)` gibt Fehlermeldung aus: `printf("%s: %s\n",s,strerror(errno))`

### Bibliothek `ctype.h`

- `int toupper(int)` und `int tolower(int)`
- Bei `is..()` muß das einzige Argument `EOF` oder vom Typ `unsigned char` sein
- Ergebnis ist ein Wert ungleich `0`, wenn das Zeichen zur Gruppe gehört
- Umlaute sind keine Buchstaben
- `int isalnum(int)` Buchstabe oder Ziffer
- `int isalpha(int)` Buchstabe
- `int iscntrl(int)` Steuerzeichen
- `int isdigit(int)` Dezimale Ziffer
- `int isgraph(int)` Sichtbares Zeichen ohne Leerzeichen
- `int islower(int)` Kleinbuchstaben
- `int isprint(int)` Druckbares Zeichen mit Leerzeichen
- `int ispunct(int)` Sichtbares Zeichen ohne Leerzeichen, Buchstaben, Ziffern
- `int isspace(int)` Leerzeichen, `\f`, `\n`, `\r`, `\t`, `\v`
- `int isupper(int)` Großbuchstaben
- `int isxdigit(int)` Hexadezimale Ziffern

### Bibliothek `string.h`

#### Stringfunktionen

- `char *strcpy(char *ziel, const char *quelle)` liefert `ziel`, kopiert ganzen String incl. Nullbyte
- `char *strncpy(char *ziel, const char *quelle, size_t anz)` liefert `ziel`, kopiert maximal `anz` Zeichen und füllt mit Nullbyte auf, Abschluß mit Nullbyte nicht gewährleistet
- `char *strcat(char *ziel, const char *quelle)` liefert ziel, hängt ganzen String an
- `char *strncat(char *ziel, const char *quelle, size_t anz)` liefert ziel, hängt bis zu `anz` Zeichen vom String plus Nullbyte an
- `int strcmp(const char *s1, const char *s2)` liefert kleiner/gleich/größer Null, wenn String `s1` lexikalisch vor/gleich/hinter `s2`
- `int strncmp(const char *s1, const char *s2, size_t anz)` wie `strcmp()`, wobei die Strings intern auf maximal `anz` Zeichen abgekürzt werden
- `char *strchr(const char *s, char c)` liefert Zeiger auf erstes Auftreten von `c` in `s` oder `NULL`
- `char *strrchr(const char *s, char c)` liefert Zeiger auf letztes Auftreten von `c` in `s` oder `NULL`
- `size_t strspn(const char *s, const char *set)` liefert Anzahl der Zeichen am Anfang von `s`, die alle in `set` vorkommen
- `size_t strcspn(const char *s, const char *set)` liefert Anzahl der Zeichen am Anfang von `s`, die alle nicht in `set` vorkommen
- `char *strpbrk(const char *s, const char *set)` liefert Zeiger auf erste Position in `s`, an der ein Zeichen aus `set` vorkommt
- `char *strstr(const char *vergl, const char *such)` liefert Zeiger auf erstes Auftreten des Strings `such` im String `vergl`
- `size_t strlen(const char *s)` liefert Länge von `s` ohne Nullbyte
- `char *strerror(int errno)` liefert Zeiger auf Fehlertext zur Fehlernummer
- `char *strtok(char *s, const char *delims)` liefert Zeiger auf das erste bzw. bei `s` = `NULL` das nächste Auftreten eines von Zeichen aus `delims` begrenzten Strings oder `NULL`, der Delimiter in `s` hinter diesem Auftreten wird durch ein Nullbyte überschrieben, bei jedem Aufruf können andere `delims` angegeben werden

#### Speicherbereichsfunktionen

- `void *memcpy(void *ziel, const void *quelle, size_t anz)` liefert `ziel`, kopiert `anz` bytes
- `void *memmove(void *ziel, const void *quelle, size_t anz)` kopiert `anz` Bytes, klappt auch bei überlappenden Bereichen
- `int memcmp(const void *m1, const void *m2, size_t anz)` wie `strncmp()`, aber Nullbytes sind kein Ende
- `int memchr(const void *m, int c, size_t anz)` liefert Zeiger auf erstes Byte `c` in `m` oder `NULL`, falls nicht in den ersten `anz` Bytes
- `void *memset(void *m, int c, size_t anz)` liefert `m`, setzt `anz` Bytes ab `m` auf `c`

### Bibliothek `limits.h`

- `CHAR_BIT` >= 8 - Anzahl Bits in `char`
- `CHAR_MAX` = `UCHAR_MAX` oder `SCHAR_MAX` - Maximaler Wert für `char`
- `CHAR_MIN` = `0` oder `SCHAR_MAX` - Minimaler Wert für `char`
- `UCHAR_MAX` >= 255 - Maximaler Wert für `unsigned char`
- `SCHAR_MAX` >= 127 - Maximaler Wert für `signed char`
- `SCHAR_MIN` <= -127 - Minimaler Wert für `signed char`
- `USHRT_MAX` >= 65535 - Maximaler Wert für `unsigned short`
- `SHRT_MAX` >= 32767 - Maximaler Wert für `short`
- `SHRT_MIN` <= -32767 - Minimaler Wert für `short`
- `UINT_MAX` >= 65535 - Maximaler Wert für `unsigned int`
- `INT_MAX` >= 32767 - Maximaler Wert für `int`
- `INT_MIN` <= -32767 - Minimaler Wert für `int`
- `ULONG_MAX` >= 4294967295 - Maximaler Wert für `unsigned long`
- `LONG_MAX` >= 2147483647 - Maximaler Wert für `long`
- `LONG_MIN` <= -2147483647 - Minimaler Wert für `long`

### Bibliothek `float.h`

- `FLT_RADIX` >= 2 - Basis der Exponentendarstellung, z. B. 2, 16
- `FLT_ROUNDS` - Art der Rundung bei Gleitkommaaddition
- `FLT_DIG` >= 6 - Genauigkeit von `float` in Dezimalziffern
- `FLT_EPS` <= 10 hoch -5 - Kleinster Wert mit `1.0 + FLT_EPS > 1.0`
- `FLT_MANT_DIG` - Länge der `float`-antisse in Basisziffern
- `FLT_MAX` >= 10 hoch 37 - Maximaler `float`-Wert
- `FLT_MAX_EPS` - Maximales n, für das `FLT_RADIX` hoch n minus 1 als `float` darstellbar
- `FLT_MIN` <= 10 hoch -37 - Minimaler `float`-Wert
- `FLT_MIN_EPS` - Minimales n, für das 10 hoch n als `float` normalisiert werden kann
- `DBL_DIG` >= 10 - Genauigkeit von `double` in Dezimalziffern
- `DBL_EPS` <= 10 hoch -9 - Kleinster Wert mit `1.0 + DBL_EPS > 1.0`
- `DBL_MANT_DIG` - Länge der `double`-antisse in Basisziffern
- `DBL_MAX` >= 10 hoch 37 - Maximaler `double`-Wert
- `DBL_MAX_EPS` - Maximales n, für das `DBL_RADIX` hoch n minus 1 als `double` darstellbar
- `DBL_MIN` <= 10 hoch -37 - Minimaler `double`-Wert
- `DBL_MIN_EPS` - Minimales n, für das 10 hoch n als `double` normalisiert werden kann

### Bibliothek `stdlib.h`

#### Umwandlung Zeichenkette nach Zahl

- Führende Zwischenräume werden ignoriert
- Danach wird umgewandelt bis zu einem ungültigen Zeichen
- Bei über- oder Unterlauf wird `errno = ERANGE` und ein spezieller Wert zurückgegeben
- `double atof(const char *s)` wandelt Zeichenkette in `double` um (wie `strtod(s,NULL)`)
- `int atoi(const char *s)` wandelt Zeichenkette in `int` um (wie `(int)strtol(s,NULL,10)`)
- `int atol(const char *s)` wandelt Zeichenkette in `long` um (wie `(int)strtol(s,NULL,10)`)
- `double strtod(const char *s,char **dahinter)` wandelt Zeichenkette in `double` um und speichert Zeiger auf ungültiges Zeichen in `dahinter`; überlaufwert `HUGE_VAL` vorzeichenrichtig, Unterlaufwert `0`
- `long strtol(const char *s,char **dahinter,int base)` wandelt Zeichenkette in `long` um und speichert Zeiger auf ungültiges Zeichen in `dahinter` ab; `base` darf 2 bis 36 (Ziffern 0 bis Z) oder 0 sein; bei 0 dient 10 oder 8 (bei führender `0`) oder 16 (bei führendem `0x` oder `0X`) als Basis; überlaufwert vorzeichenrichtig `LONG_MAX` oder `LONG_MIN`
- `unsigned long strtoul(const char *s,char **dahinter,int base)` wie `strtol`, aber Umwandlung in `unsigned long` und überlaufwert `ULONG_MAX`

#### Zufallszahlen

- `int rand(void)` liefert Zufallszahl von 0 bis `RAND_MAX` >= 32767
- `void srand(unsigned int seed)` Setzt neuen Startwert (erster Wert 1)

#### Speicherverwaltung

- `void *calloc(size_t anz,size_t size)` liefert Zeiger auf gelöschten Speicher für `anz` Elemente der Größe `size` oder `NULL`
- `void *malloc(size_t size)` liefert Zeiger auf Speicherbereich der Größe `size` oder `NULL`
- `void *realloc(void *mem, size_t size)` liefert Zeiger auf neuen Speicherbereich mit geänderter Größe `size` mit dem alten Inhalt von `mem`, `mem` wird freigegeben, größere Länge uninitialisiert, kleine Länge abgeschnitten, oder `NULL`
- `void free(void *mem)` gibt Speicher wieder frei

#### Diverses

- `void abort(void)` bricht Programm brutal ab (wie `raise(SIGABRT)`)
- `void exit(int rc)` beendet Programm wie `return(rc)` aus `main()`, `EXIT_SUCCESS`=Ok, `EXIT_FAILURE`=Fehler
- `int atexit(void (*f)(void))` liefert 0 oder Fehler, hinterlegt Funktion zur Ausführung am Ende
- `int system(const char *cmd)` bei `s`=`NULL` liefert 0, wenn kein Kommandoprozessor verfügbar, sonst implementierungsabhängig.
- `char *getenv(const char *name)` liefert Zeiger auf Umgebungsvariable oder `NULL`
- `int abs(int i)` liefert Absolutwert
- `long labs(long i)` liefert Absolutwert
- `div_t div(int n,int divisor)` liefert `struct div_t` aus `int quot` und `int rem`
- `ldiv_t ldiv(long n,long divisor)` liefert `struct ldiv_t` aus `long quot` und `long rem`
- `void qsort(void *mem,size_t anz,size_t size,int (*cmp)(const void *,`% `const void *))` sortiert Vektor von `anz` Elementen der Größe `size` mit Hilfe der Vergleichsfunktion `cmp`, die <0 / =0 / >0 liefert
- `void *bsearch(const void *key,const void *mem,size_t anz,size_t size,`% `int (*cmp)(const` `void *,const void *))` liefert Zeiger auf Element `key` im aufsteigend sortierten Vektor aus `anz` Elementen der Größe `size` mit Hilfe der Vergleichsfunktion `cmp`, die <0 / =0 / >0 liefert

### Bibliothek `math.h`

#### Fehlercodes in `errno`

- `EDOM` = Illegales Argument (Ergebnis undefiniert)
- `ERANGE` = Immer bei overflow (Ergebnis ±`HUGE_VAL`), kann bei underflow (Ergebnis 0)

#### Funktionen

- `double sin(double x)` liefert Sinus
- `double cos(double x)` liefert Cosinus
- `double tan(double x)` liefert Tangens
- `double asin(double x)` liefert Arcus Sinus [-1,1] im Bereich [-Pi/2,Pi/2]
- `double acos(double x)` liefert Arcus Cosinus [-1,1] im Bereich [0,Pi]
- `double atan(double x)` liefert Arcus Tangens im Bereich ]-Pi/2,Pi/2[
- `double atan2(double y,double x)` liefert Arcus Tangens (`y`/`x`) im Bereich [-Pi,Pi]
- `double sinh(double x)` liefert Sinus hyperbolicus
- `double cosh(double x)` liefert Cosinus hyperbolicus
- `double tanh(double x)` liefert Tangens hyperbolicus
- `double exp(double x)` liefert e hoch x
- `double log(double x)` liefert ln(x), x>0
- `double log10(double x)` liefert lg(x), x>0
- `double pow(double x,double y)` liefert x hoch y, Fehler wenn x=0 und y<=0 oder x<0 und y nicht ganzzahlig
- `double sqrt(double x)` liefert Wurzel aus x
- `double ceil(double x)` liefert kleinste ganze Zahl >= `x`
- `double floor(double x)` liefert größte ganze Zahl <= `x`
- `double fabs(double x)` liefert |x|
- `double ldexp(double x,int n)` liefert x mal 2 hoch n
- `double frexp(double x,int *n)` (Gegenteil zu `ldexp`) liefert Mantisse in [1/2,1[, Exponent nach `*n`
- `double modf(double x,double *i)` liefert Ganzzahliger Teil, Rest nach `*i`, beides mit Vorzeichen von `x`
- `double fmod(double x,double y)` liefert Rest von `x`/`y` mit Vorzeichen von `x`, bei `y=0` implementierungsabhängig

### Bibliothek `assert.h`

- `void assert(int ausdruck)` (Makro) bricht, wenn `ausdruck`=`0`, Programm mit Meldung `Assertion failed: ausdruck, file filename, line nnn` ab
- `assert()` dient zur Kontrolle der Richtigkeit eines Programms und kann durch Definition von `NDEBUG` vor `#include <assert.h>` ausgeschaltet werden

### Bibliothek `setjmp.h`

#### Nichtlokale Sprünge

- `int setjmp(jmp_buf buffer)` liefert 0 beim Aufruf und ungleich 0 beim Sprung, definiert Sprungmarke
- `int longjmp(jmp_buf buffer, int n)` springt zum mit `setjmp(buffer)` definierten Ort, `n` ist dann das von 0 verschiedene Ergebnis von `setjmp`
- Vorsicht: Die Funktion, in der `setjmp` aufgerufen wurde, muß bei `longjmp` noch aktiv sein, `auto`- und `register`-Variablen ohne `volatile` in dieser Funktion sind beim Ansprung über `longjmp` undefiniert
- `if(setjmp(buffer)){` ... von `longjmp()` ... `}else{` ... direkt ... `}` ...

### Bibliothek `signal.h`

#### Behandlung von Ausnahmebedingungen

- `void (*signal(int sig,void (*handler)(int)))(int)` setzt neuen `handler()` für Signaltyp `sig` und liefert alten `handler()`
- `int raise(int sig)` liefert 0 oder Fehler, sendet Signal `sig` ab

#### Signaltypen

- `SIGABRT` anomaler Programmabbruch (z. B. durch `abort()`)
- `SIGFPE` Arithmetikfehler wie Division durch Null oder Overflow
- `SIGILL` Illegaler Funktionstext oder Maschinenbefehl
- `SIGINT` Unterbrechung von Tastatur o. ä.
- `SIGSEGV` Illegaler Speicherzugriff
- `SIGTERM` Aufforderung zum Programmende
- u. a.

#### Handler

- `SIG_DFT` Der voreingestellte Handler
- `SIG_IGN` Ignorieren des Signals
- `SIG_ERR` (Rückgabewert von `signal()` bei Fehler)
- `void (*handler)(int)` Eigener Handler, Argument ist Signaltyp
- Beim Ende des Handlers an der Unterbrechungsstelle weitergemacht (wenn nicht `exit()`, `longjmp()` o. ä. verwendet wird)

### Bibliothek `time.h`

#### Kalenderzeittyp `time_t`

#### Ortszeit-Struktur `struct tm`

- `int tm_sec` Sekunden nach voller Minute (0-61)
- `int tm_min` Minuten nach voller Stunde (0-59)
- `int tm_hour` Stunden seit Mitternacht (0-23)
- `int tm_mday` Tag im Monat (1-31)
- `int tm_mon` Monat nach Januar (0-11)
- `int tm_year` Jahr minus 1900
- `int tm_wday` Wochentag (0-6, 0=Sonntag)
- `int tm_yday` Tag im Jahr nach 1. Januar (0-365)
- `int tm_isdst` >0 Sommerzeit, =0 Winterzeit, <0 unbekannt

#### Funktionen, die die aktuelle Zeit liefern

- `clock_t clock(void)` liefert Systemticks seit Programmstart oder -1; Sekunden = `clock()` ÷ `CLOCKS_PER_SEC`
- `time_t time(time_t *zeit)` liefert Kalenderzeit oder -1, wenn `zeit` ungleich `NULL` auch nach `zeit`

#### Funktionen, die mit Zeiten rechnen

- `struct tm *localtime(const time_t *zeit)` liefert Zeiger auf statische Struktur mit Ortszeit
- `struct tm *gmtime(const time_t *zeit)` liefert Zeiger auf statische Struktur mit UTC (früher GMT) oder `NULL`
- `double difftime(time_t zeit2,time_t zeit1)` liefert Zeitdifferenz in Sekunden
- `time_t mktime(struct tm *zeit)` wandelt `struct tm` in `time_t` um, -1 bei Fehler
- `char *asctime(const struct tm *zeit)` liefert Statische Zeichenkette in der Form `"Mon Dec 31 23:59:59 1990\n"`
- `char *ctime(const time_t *zeit)` liefert `asctime(localtime(*zeit))`
- `size_t strftime(char *s,size_t maxsize,const char *fmt,const struct`% `tm *werte)` legt Uhrzeit `werte` im Format `fmt` in Speicherbereich `s` der Länge `maxsize` ab, liefert Länge ohne `\0` oder 0, wenn es nicht paßt

#### Formatangaben für `strftime`

- `%a` Abgekürzter Name des Wochentags
- `%A` Voller Name des Wochentags
- `%b` Abgekürzter Name des Monats
- `%B` Voller Name des Monats
- `%c` Lokale Darstellung von Datum und Zeit
- `%d` Tag im Monat (01-31)
- `%H` Stunde (00-23)
- `%I` Stunde (00-11)
- `%j` Tag im Jahr (001-366)
- `%m` Monat (01-12)
- `%M` Minute (00-59)
- `%p` lokale Form von AM oder PM
- `%s` Sekunde (00-61)
- `%U` Woche im Jahr (Sonntag erster Wochentag, 00-53)
- `%w` Wochentag (0-6, Sonntag=0)
- `%W` Woche im Jahr (Montag erster Wochentag, 00-53)
- `%x` Lokale Form des Datums
- `%X` Lokale Form der Zeit
- `%y` Jahr zweistellig (00-99)
- `%Y` Jahr vierstellig (1900-)
- `%Z` Name der Zeitzone, falls gegeben
- `%%` Steht für `%`

Zum Inhaltsverzeichnis | Zum nächsten Abschnitt

###### Copyright © FH München, FB 04, Prof. Jürgen Plate