Algorithmen und Datenstrukturen

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

# Die Standard-Bibliotheks-Funktionen

abort abs acos asctime asin assert atan atan2 atexit atof atoi atol bsearch calloc ceil clearerr clock closedir | chdir cos cosh ctime difftime div exit exp fabs fclose feof ferror fflush fgetc fgetpos fgets floor fmod | fopen fprintf fputc fputs fread free freopen frexp fscanf fseek fsetpos ftell fwrite getc getchar getenv gets gmtime | isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit labs ldexp ldiv localtime log log10 longjmp | malloc memchr memcmp memcpy memmove memset mktime modf opendir perror popen pclose pow printf putc putchar puts qsort | raise rand readdir realloc remove rename rewind scanf seekdir setbuf setjmp setvbuf signal sin sinh sprintf sqrt srand | sscanf strcat strchr strcmp strcpy strcspn strerror strlen strncat strncmp strncpy strpbrk strrchr strcspn strstr strtod strtok strtol | strtoul system tan tanh telldir time tmpfile tmpnam tolower toupper ungetc va_arg va_end va_start vfprintf vprintf vsprintf

## abort

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `void abort(void);`
Rückgabewert: | keiner
Beschreibung: | Gibt die Meldung `Abnormal program termination` auf der Fehlerausgabe `stderr` aus und bricht den laufenden Prozess ab (normaler Programmabbruch siehe `exit()`).
Beispiel: |
    if (fp= fopen("/etc/passwd","r") == NULL)
      { printf("Datei nicht gefunden!\n"); abort(); }

## abs

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `int abs(int x);`
Rückgabewert: | Absolutbetrag von x
Beschreibung: | Berechnet den Absolutwert des int-Wertes x (siehe auch labs und fabs).
Beispiel: |
    printf("abs(-8) = %d\n",abs(-8));
    /* Ausgabe: abs(-8) = 8 */

## acos

Bibliothek: | `#include <math.h>`
Prototyp: | `double acos(double x);`
Rückgabewert: | Arcuscosinus von x im Bogenmaß (zwischen 0 und Pi); Im Fehlerfall 0, und gleichzeitig Fehlermeldung auf `stderr`, Fehlervariable `errno` = `EDOM` (domain error)
Beschreibung: | Berechnet den Arcuscosinus des Argumentes`x` (-1 <= x <= +1)
Beispiel: |
    printf("acos(-1.0) = %6.4f\n",acos(-1.0));
    /* Ausgabe: acos(-1.0) = 3.1416 */

## asctime

Bibliothek: | `#include <time.h>`
Prototyp: | `char *asctime(struct tm *systime);`
Rückgabewert: | Zeiger auf String mit Datum und Uhrzeit (26 Bytes lang)
Beschreibung: | Konvertiert Datum und Uhrzeit in einen String. Datum und Uhrzeit sind in der durch `systime` addressierten Struktur von Type `tm` abgelegt (wurde zuvor mit `localtime` oder `gmtime` angelegt und mit Werten gefüllt). Die Ortszeit-Struktur `struct tm` hat folgende Elemente: `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
Beispiel: |
    struct tm *systime;
    time_t sec;
    time(&sec);
    systime = localtime (&sec);
    printf("Datum und Uhrzeit: %s\n",asctime(systime));
    /* Ausgabe: Datum und Uhrzeit: Mon Jul 18 9:00:48 2005 */

## asin

Bibliothek: | `#include <math.h>`
Prototyp: | `double asin(double x);`
Rückgabewert: | Arcussinus von x im Bogenmaß (Wert zwischen -Pi/2 und +Pi/2); Im Fehlerfall 0 und Fehlermeldung auf `stderr`, Fehlervariable `errno` = `EDOM`
Beschreibung: | Berechnet den Arcussinus des Argumentes x (-1 <= x <= +1).
Beispiel: |
    printf("asin(-1.0) = %7.4f",asin(-1.0));
    /* Ausgabe: asin(-1.0) = -1.5708 */

## assert

Bibliothek: | `#include <assert.h>`
Prototyp: | `void assert(int expression);`
Rückgabewert: | keiner
Beschreibung: | Das Makro überprüft den Ausdruck `expression`, um logische Fehler im Programm zu finden. Ist das Ergebnis 0 (Fehler), so wird die Meldung: "`Assertion failed: expression, file: name, line: number`" ausgegeben. Danach erfolgt Programmabbruch.
Beispiel: |
    double x = -1.0, y, z;
    y = sin(x) - cos(x);
    assert(y > 0);
    z = log(y); /* log(y) nur für positive y definiert */
    /* Ausgabe: Assertion failed: y > 0, file ... */

## atan

Bibliothek: | `#include <math.h>`
Prototyp: | `double atan(double x);`
Rückgabewert: | Arcustangens von x im Bogenmaß (zwischen -Pi/2 und +Pi/2)
Beschreibung: | Berechnet den Arcustangens des Argumentes x; Umkehrfunktion des Tangens.
Beispiel: |
    printf("atan(-1.0) = %7.4f\n", atan(-1.0));
    /* Ausgabe: atan(-1.0) = -0.7854 */

## atan2

Bibliothek: | `#include <math.h>`
Prototyp: | `double atan2(double y, double x);`
Rückgabewert: | Gibt einen Wert zwischen -Pi/2 und +Pi/2 zurück. Sind die Argumente x und y beide 0, so erhält die Fehlervariable `errno` den Wert `EDOM` und eine Fehlermeldung wird auf `stderr` ausgegeben. Der Rückgabewert ist in diesem Fall 0.
Beschreibung: | Berechnet den Arcustangens von y/x.
Beispiel: |
    double x = 3, y = 3; /* y/x = 1 */
    printf("atan2(y,x) = %10f\n",atan2(y,x));
    /* Ausgabe: atan2(y,x) = 0.785398 */

## atexit

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `int atexit(void(*func)(void));`
Rückgabewert: | Im Fehlerfall ein Wert ungleich 0, sonst 0.
Beschreibung: | Der Funktion `atexit` wird ein Zeiger `func` auf eine Funktion vom Typ `void` übergeben, die am Ende des Programms aufgerufen werden soll. Durch mehrere aufeinanderfolgende Aufrufe von `atexit` werden Zeiger auf weitere Funktionen registriert, die nach dem Stack-Prinzip (last in first out) verwaltet werden.
Beispiel: |
    void func1(void)
      { printf("Das ist Funktion func1.\n");}

    void func2(void)
      { printf("Das ist Funktion func2.\n");}

    main()
      {
      atexit(func1);
      atexit(func2);
      printf("\nEnde des Programms.\n");
      }
    /* Ausgabe:
      Ende des Programms.
      Das ist Funktion func2.
      Das ist Funktion func1. */

## atof

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `double atof(const char *s);`
Rückgabewert: | Gibt den double-Wert der in der Zeichenkette gespeicherten Zahl zurück. Bei nicht auswertbarer Zeichenkette wird 0 zurückgegeben.
Beschreibung: | Wandelt eine als Zeichenkette gespeicherte Zahl in einen Wert vom Typ double um. Beim ersten Zeichen, das nicht als Teil einer Gleitpunktzahl interpretiert werden kann, wird die Umwandlung beendet. Leerzeichen werden ignoriert.
Beispiel: |
    char *string = "-12.356e+2";
    double z;
    z= atof(string);
    printf("z = %.2f\n",z);
    /* Ausgabe: z = -1235.60 */

## atoi

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `int atoi(const *s);`
Rückgabewert: | Gibt den int-Wert der in der Zeichenkette gespeicherten Zahl zurück. Falls eine Auswertung nicht möglich ist, wird 0 zurückgegeben.
Beschreibung: | Wandelt eine als Zeichenkette gespeicherte dezimale Ganzzahl in einen int-Wert um. Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung beendet. Ein Dezimalpunkt oder Exponent wird nicht als Teil der Zahl angesehen.
Beispiel: |
    char *s= "+123 Autos";
    printf("atoi(s) = %d\n",atoi(s));
    /* Ausgabe: atoi(s) = 123 */

## atol

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `long atol(const char *s);`
Rückgabewert: | Gibt den long-Wert der in der Zeichenkette gespeicherten Zahl zurück. Falls eine Auswertung nicht möglich ist, wird 0 zurückgegeben.
Beschreibung: | Wandelt eine als Zeichenkette gespeicherte dezimale Ganzzahl in einen long-Wert um. Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung beendet. Ein Dezimalpunkt oder Exponent wird nicht als Teil der Zahl angesehen.
Beispiel: |
    char *s= "12345678.-- Dollar";
    printf("atol(s) = %ld\n",atol(s));
    /* Ausgabe: atol(s) = 12345678 */

## bsearch

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `void *bsearch (const void *key, const void *array, `size_t` n, `size_t` size, int (*compare)());`
Rückgabewert: | Gibt einen Zeiger auf das erste Vektorelement zurück, das mit dem gesuchten Wert übereinstimmt. Gibt es ein solches Vektorelement nicht, so wird der NULL-Zeiger zurückgegeben.
Beschreibung: | Verwendet binäre Suche, um in einem sortierten Vektor `array` nach dem durch `key` adressierten Wert zu suchen. Der Vektor enthält `n` Vektorelemente der Größe `size`. Der Datentyp `size_t` ist in `stdlib.h` als `unsigned int` definiert. Das letzte Argument `compare` ist ein Zeiger auf eine Funktion, die den gesuchten Wert mit einem Vektorelement vergleicht.
Beispiel: |
    int scmp(char **s1, char **s2) { return strcmp(*s1, *s2); }

    main()
      {
      char *farben[] =
        {"rot","orange","gelb","grün","blau","violett"};
      char *key = "schwarz";

      ...

      if (bsearch(key,farben,5,sizeof(char*),scmp) == NULL)
        printf("Farbe %s nicht gefunden\n",key);
      ...
      }

## calloc

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `void *calloc(size_t n, size_t size);`
Rückgabewert: | Zeiger auf Anfangsadresse des zugeteilten Speicherbereiches
Beschreibung: | Reserviert Platz im Hauptspeicher für einen Vektor mit `n` Elementen der Größe `size`. `size_t` ist in `stdlib.h` als `unsigned int` definiert. Jedes Element wird mit dem Wert 0 initialisiert. Ist nicht genügend Speicherplatz vorhanden, wird ein NULL-Zeiger zurückgeliefert.
Beispiel: |
    if (calloc(5,sizeof(int)) == NULL)
      printf("Nicht genügend Speicher\n");

## chdir

Bibliothek: | `#include <unistd.h>`
Prototyp: | `int chdir (const char *pfad);`
Rückgabewert: | im Erfolgsfall 0, im Fehlerfall -1
Beschreibung: | Wechsel in das angegebene Verzeichnis.
Beispiel: |
    erg = chdir("/var/log/");

## ceil

Bibliothek: | `#include <math.h>`
Prototyp: | `double ceil(double x);`
Rückgabewert: | x aufgerundet
Beschreibung: | Liefert kleinste ganze Zahl, die größer oder gleich x ist (Aufrundung).
Beispiel: |
    printf("ceil(2.3) = %4.1f\n", ceil(2.3));
    /* Ausgabe: ceil(2.3) = 3.0 */

## clearerr

Bibliothek: | `#include <stdio.h>`
Prototyp: | `void clearerr(FILE *fp);`
Rückgabewert: | keiner
Beschreibung: | Löscht das Fehler-Flag und das Dateiende-Flag der mit `fp` verbundenen Datei.
Beispiel: |
    clearerr(fp);

## clock

Bibliothek: | `#include <time.h>`
Prototyp: | `clock_t clock (void);`
Rückgabewert: | Prozessorzeit in "Ticks" (systemabhängig)
Beschreibung: | Bestimmt die Prozessorzeit, die das aufrufende Programm bis dahin verbraucht hat. `clock_t` ist in `time.h` als long definiert. Die Einheit für Prozessorzeit ist abhängig vom Compiler. Durch Division mit der in `time.h` definierten Konstanten `CLK_TCK` sollte das Ergebnis in Sekunden umgerechnet werden.
Beispiel: |
    z = clock();
    /* weist z die Anzahl von "Ticks" zu,
    die seit Programmstart vergangen sind */

## closedir

Bibliothek: | `#include <dirent.h>` `#include <sys/types.h>`
Prototyp: | `int closedir (DIR *dirp);`
Rückgabewert: | im Erfolgsfall 0, im Fehlerfall -1
Beschreibung: | Schliesst einen Verzeichnis-Stream und gibt die belegten Resourcen zurück.
Beispiel: |
    erg = closedir(dir);

## cos

Bibliothek: | `#include <math.h>`
Prototyp: | `double cos(double x);`
Rückgabewert: | cos(x)
Beschreibung: | Liefert den Cosinus von x (im Bogenmaß). Ist der Argumentwert zu groß für ein signifikantes Ergebnis, so wird 0 zurückgegeben und `errno` erhält den Wert `ERANGE`.
Beispiel: |
    printf("cos(0.0) = %4.1f\n", cos(0.0));
    /* Ausgabe: cos(0.0) = 1.0 */

## cosh

Bibliothek: | `#include <math.h>`
Prototyp: | `double cosh(double x);`
Rückgabewert: | `cosh(x)`
Beschreibung: | Liefert den Cosinus Hyperbolicus von x. Ist das Ergebnis zu groß, so wird `HUGE_VAL` zurückgegeben und `errno` erhält den Wert `ERANGE`.
Beispiel: |
    printf("cosh(-2.0) = %6.4f\n", cosh(-2.0));
    /* Ausgabe: cosh(-2.0) = 3.7622 */

## ctime

Bibliothek: | `#include <time.h>`
Prototyp: | `char *ctime(const time_t *zeit);`
Rückgabewert: | Anfangsadresse des Zeitstrings
Beschreibung: | Konvertiert Datum und Uhrzeit in einen String. `zeit` ist die Anzahl der Sekunden seit der UNIX-Epoche, dem 1.1.1970 00:00:00 Uhr (GMT). Der erzeugte String hat das Format `Wochentag Monat Monatstag Zeit (hh:mm:ss) Jahr (vierstellig)`. `time_t` ist in `time.h` als long definiert.
Beispiel: |
    time_t sec;
    time(&sec);
    printf("Datum und Zeit: %s\n", ctime(&sec));
    /* Ausgabe: Datum und Zeit: Mon Oct 28 09:15:48 1996 */

## difftime

Bibliothek: | `#include <time.h>`
Prototyp: | `double difftime(time_t time2, time_t time1);`
Rückgabewert: | Differenz `time2 - time1`
Beschreibung: | Berechnet die Differenz von `time2` und `time1` als double-Wert in Sekunden `time_t` ist in `time.h` als long definiert ein solcher Wert wird von `time()` geliefert.
Beispiel: |
    printf("Arbeitszeit: %.0f Sekunden\n", difftime(stoptime,starttime));
    /* Ausgabe der Differenz zwischen starttime und stoptime */

## div

Bibliothek: | `#include <stdlib.h>` Protoyp: ``div_t` div(int x,int y);`
Rückgabewert: | Struktur vom Typ `div_t`
Beschreibung: | Dividiert x durch y und legt Ergebnis und Rest in einer Struktur vom Typ `div_t` ab. `div_t` ist in `stdlib.h` definiert.
Beispiel: |
    div_t res;
    res = div(10,3);
    printf("10/3 = %d, Rest %d\n",res.quot,res.rem);
    /* Ausgabe: 10/3 = 3 Rest 1 */

## exit

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `void exit(int status);`
Rückgabewert: | keiner
Beschreibung: | Beendet ein Programm. Dateipuffer werden übertragen und Dateien werden geschlossen. `status` stellt den Exit-Code dar.
Beispiel: |
    exit(1); /* beendet das Programm und liefert den
    Exit-Code 1 zurück */

## exp

Bibliothek: | `#include <math.h>`
Prototyp: | `double exp(double x);`
Rückgabewert: | ex
Beschreibung: | Berechnet den Wert der Exponentialfunktion für x.
Beispiel: |
    printf("exp(-3.0) = %7.4f\n", exp(-3.0));
    /* Ausgabe: exp(-3.0) = 0.0498 */

## fabs

Bibliothek: | `#include <math.h>`
Prototyp: | `double fabs(double x);`
Rückgabewert: | `| x |`
Beschreibung: | Liefert den Absolutwert einer Gleitkommazahl
Beispiel: |
    printf("fabs(-3.8) = %3.1f\n", fabs(-3.8));
    /* Ausgabe: fabs(-3.8) = 3.8 */

## fclose

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int fclose(FILE *fp);`
Rückgabewert: | Datei geschlossen: 0; ungültiger File-Pointer: EOF
Beschreibung: | Schließt die mit `fp` verbundene Datei überträgt den Inhalt des Dateipuffers. Der Speicherbereich des E/A-Puffers wird wieder freigegeben.
Beispiel: |
    if (fclose(fp) == 0)
      printf("Datei wurde geschlossen\n");

## feof

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int feof(FILE *fp);`
Rückgabewert: | Dateiende-Flag gesetzt: Wert ungleich 0; andernfalls 0
Beschreibung: | Das Makro prüft, ob das Dateiende erreicht ist.
Beispiel: |
    while (!feof(fp))
      /* führt nachfolgenden Befehl solange aus,
      bis das Dateiende erreicht ist */

## ferror

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int ferror(FILE *fp);`
Rückgabewert: | Fehler-Flag gesetzt: Wert ungleich 0; andernfalls 0
Beschreibung: | Das Makro überprüft, ob ein Fehler beim Zugriff auf eine Datei auftrat.
Beispiel: |
    if (ferror(fp))
      printf("Fehler beim Zugriff\n");

## fflush

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int fflush(FILE *fp);`
Rückgabewert: | Im Fehlerfall EOF, andernfalls 0
Beschreibung: | Überträgt den Inhalt des Dateipuffers: Schreibmodus: Dateipuffer wird geschrieben Lesemodus: Puffer wird geleert
Beispiel: |
    if (fflush(fp) == EOF)
      printf("Puffer nicht geschrieben\n");

## fgetc

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int fgetc(FILE *fp);`
Rückgabewert: | gelesenes Zeichen, bei Fehler oder Dateiende EOF
Beschreibung: | Liest aus der Datei das Zeichen von der aktuellen Position (Dateizeiger wird um eins erhöht).
Beispiel: |
    c = fgetc(fp);
    /* weist c das nächste Zeichen der Datei zu */

## fgetpos

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int fgetpos(FILE *fp, fpos_t *ppos);`
Rückgabewert: | Im Fehlerfall Wert ungleich 0; sonst 0
Beschreibung: | Ermittelt die aktuelle Position in der Datei und kopiert aktuelle Position in durch `ppos` adressierte Variable. `fpos_t` ist in `stdio.h` als long definiert. Im Fehlerfall erhält `errno` den Wert `EINVAL` oder `EBADF`.
Beispiel: |
    fgetpos(fp,&pos);
    /* sichert aktuelle Position in pos */

## fgets

Bibliothek: | `#include <stdio.h>`
Prototyp: | `char *fgets(char *string, int n, FILE *fp);`
Rückgabewert: | Im Fehlerfall ein NULL-Pointer, andernfalls einen Zeiger auf `string`
Beschreibung: | Liest Zeichenfolge aus der Datei und kopiert sie in einen durch `string` adressierten Speicherbereich; am Ende wird "\0" angefügt. Eingelesen wird bis n-1 Zeichen gelesen wurden oder bis ein Newline-Zeichen auftritt.
Beispiel: |
    if (fgets(name,21,fp) != NULL)
      printf("1. Name: %s\n", name);
      /* Ausgabe: 1. Name: xxxx */

## floor

Bibliothek: | `#include <math.h>`
Prototyp: | `double floor(double x);`
Rückgabewert: | x abgerundet
Beschreibung: | Ermittelt die größte ganze Zahl, die kleiner oder gleich x ist (Abrundung)
Beispiel: |
    printf("floor(1.9) = %4.1f\n", floor(1.9));
    /* Ausgabe: floor(1.9) = 1 */

## fmod

Bibliothek: | `#include <math.h>`
Prototyp: | `double fmod(double x,double y);`
Rückgabewert: | Rest der Division x/y
Beschreibung: | Modulo-Division der double-Werte x und y
Beispiel: |
    printf("fmod(9.5,4.5) = %3.1f\n", fmod(9.5,4.5));
    /* Ausgabe: fmod(9.5,4.5) = 0.5 */

## fopen

Bibliothek: | `#include <stdio.h>`
Prototyp: | `FILE *fopen(const char *name, const char *modus);`
Rückgabewert: | File-Pointer; im Fehlerfall NULL
Beschreibung: | Öffnet eine Datei `name` in der Zugriffsart `modus`. Durch Anhängen des Buchstabens "t" bzw. "b" an `modus` kann zwischen Binär- und Textmodus gewählt werden (falls das Betriebssystem hier unterscheidet). `FILE` ist in `stdio.h` definiert. Liste der verschiedenen Modi:
"r" | Lesen (Datei muß existieren)
"r+" | Lesen/Schreiben (Datei muß existieren)
"w" | Schreiben (wenn Datei nicht existiert, wird sie angelegt)
"w+" | Lesen / Schreiben (wenn Datei nicht existiert, wird sie angelegt)
"a" | Schreiben ab Dateiende
"a+" | Schreiben ab Dateiende / Lesen
Beispiel: |
    fp = fopen("bsp.txt","r");
    /* öffnet die bereits existierende Datei bsp.txt
    zum Lesen (fp wird mit der Datei verbunden) */

## fprintf

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int fprintf(FILE *fp,const char formatstring, ... );`
Rückgabewert: | Anzahl der ausgegebenen Zeichen; im Fehlerfall EOF
Beschreibung: | Schreibt entsprechend den Angaben im Formatstring in die mit `fp` verbundene Datei (siehe auch `printf`).
Beispiel: |
    fprintf(fp,"2 * 2 = %d \n",2*2);
    /* Ausgabe von: 2 * 2 = 4 in die Datei */

## fputc

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int fputc(int c,FILE *fp);`
Rückgabewert: | Im Fehlerfall EOF; andernfalls ausgegebenes Zeichen
Beschreibung: | Schreibt das Zeichen c auf die aktuelle Dateiposition (wirkungsgleich mit dem Makro `putc`)
Beispiel: |
    fputc(c,fp);
    /* schreibt das Zeichen c an die
    aktuelle Position in die Datei */

## fputs

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int fputs(const char *string, FILE *fp);`
Rückgabewert: | Im Fehlerfall EOF; andernfalls von EOF verschiedener Wert
Beschreibung: | Schreibt die Zeichenkette `string` in Datei. Das Stringende-Zeichen '\0' wird nicht in die Datei geschrieben.
Beispiel: |
    fputs(string,fp);
      /* schreibt string in die Datei */

## fread

Bibliothek: | `#include <stdio.h>`
Prototyp: | `size_t fread(void *buffer, size_t size, size_t n, FILE *fp);`
Rückgabewert: | Anzahl der tatsächlich gelesenen Datenobjekte (ist diese kleiner n -> Fehler oder EOF)
Beschreibung: | Liest bis zu n Datenobjekte der Länge `size` aus der Datei ein und schreibt sie in den Speicherbereich mit Startadresse `puffer`. `size_t` ist in `stdio.h` als `unsigned int` definiert.
Beispiel: |
    fread(puffer,sizeof(pufferelement),100,fp);
    /* liest 100 Elemente aus der Datei in den puffer */

## free

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `void free(void *ptr);`
Rückgabewert: | keiner
Beschreibung: | Gibt den Speicherbereich frei, auf dessen Anfang `ptr` zeigt (Speicher muß zuvor durch `malloc`, `calloc` oder `realloc` reserviert worden sein). Ist `ptr` ein NULL-Zeiger, passiert nichts.
Beispiel: |
    free(ptr);

## freopen

Bibliothek: | `#include <stdio.h>`
Prototyp: | `FILE *freopen(const char *name, const char *modus, FILE *fp);`
Rückgabewert: | File-Pointer für die neu geöffnete Datei; im Fehlerfall NULL-Zeiger
Beschreibung: | Schließt die mit `fp` verbundene Datei und öffnet die Datei `name` mit der Zugriffsart `modus` unter Verwendung des alten Filepointers (Beschreibung der Zugriffsarten bei `fopen`)
Beispiel: |
    freopen("bsp.txt","w",stdout);
    /* lenkt die Standardausgabe in die Datei bsp.txt um */

## frexp

Bibliothek: | `#include <math.h>`
Prototyp: | `double frexp(double x, int *ptr);`
Rückgabewert: | Wert der Mantisse
Beschreibung: | Zerlegt den double-Wert x in Mantisse `m` und Exponent `exp` (zur Basis 2). Der Exponent `exp` wird an der durch `ptr` adressierten Speicherstelle abgelegt. Ist x=0, dann erhalten `m` und `exp` den Wert 0.
Beispiel: |
    m = frexp(9.5,&exp);
    printf("Mantisse m = %f, exp = %d\n",m,exp);
    /* Ausgabe: Mantisse m = 0.5937..., exp = 4 */

## fscanf

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int fscanf(FILE *fp, const char *formatstring [,arg1,arg2,..]);`
Rückgabewert: | Anzahl der tatsächlich gelesenen Datenfelder; falls das Dateiende erreicht wurde EOF
Beschreibung: | Liest Elemente aus der Datei, interpretiert sie unter Kontrolle des Formatstrings und legt sie in den durch `arg1, arg2,` ... adressierten Speicherplätzen ab. `formatstring` wird in der bei `scanf` beschriebenen Weise gebildet `arg1, ...` ist ein Zeiger auf eine Variable, deren Typ mit der entsprechenden Typangabe im Format-String übereinstimmen muß.
Beispiel: |
    fscanf(fp,"%10s %ld",name,&nummer);
    printf("name = %s nummer = %ld\n",name,nummer);

## fseek

Bibliothek: | `#include <stdio.h>` Protoyp: `int fseek(FILE *fp, long offset, int basis);`
Rückgabewert: | Im Fehlerfall Wert ungleich 0; andernfalls 0
Beschreibung: | Verschiebt den Datei-Zeiger um `offset` Bytes vom Dateianfang, falls `basis` = 0 von der aktuellen Position, falls `basis` = 1 vom Dateiende, falls `basis` = 2 Der Zeiger darf nicht vor den Anfang der Datei gesetzt werden.
Beispiel: |
    fseek(fp,48L,0);
    /* setzt den Seek-Zeiger 48 Bytes nach Dateianfang */

## fsetpos

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int fsetpos(FILE *fp,const fpos_t *ppos);`
Rückgabewert: | 0; im Fehlerfall von 0 verschiedener Wert
Beschreibung: | Setzt den Seek-Zeiger der Datei an die neue Position `*ppos` (z.B. durch `fgetpos` ermittelt). `fpos_t` ist in `stdio.h` als `long` definiert. Tritt ein Fehler auf, so erhält `errno` den Wert `EINVAL` oder `EBADF`.
Beispiel: |
    fsetpos(fp,&pos);
    /* setzt den Seek-Pointer der Datei an die durch pos
    gekennzeichnete Stelle */

## ftell

Bibliothek: | `#include <stdio.h>`
Prototyp: | `long ftell(FILE *fp);`
Rückgabewert: | aktuelle Position des Seek-Zeigers; im Fehlerfall -1L
Beschreibung: | Ermittelt die aktuelle Position in der Datei. Im Fehlerfall erhält `errno` den Wert `EINVAL` (invalid argument) oder `EBADF` (bad file number).
Beispiel: |
    pos = ftell(fp);
    /* pos wird die aktuelle Position
    in der Datei zugewiesen */

## fwrite

Bibliothek: | `#include <stdio.h>`
Prototyp: | `size_t fwrite(void *buffer, size_t size, size_t n, FILE *fp);`
Rückgabewert: | Anzahl der Datenobjekte, die tatsächlich in die Datei geschrieben wurden.
Beschreibung: | Schreibt n Datenobjekte der Größe `size` aus dem durch `buffer` adressierten Puffer in die Datei. `size_t` ist in `stdio.h` als `unsigned int` definiert.
Beispiel: |
    fwrite(puffer,sizeof(pufferelement),4,fp);
    /* schreibt 4 pufferelemente aus puffer in die Datei */

## getc

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int getc(FILE *fp);`
Rückgabewert: | eingelesenes Zeichen, bei Fehler oder Dateiende EOF
Beschreibung: | Das Makro liest das nächste Zeichen aus der Datei.
Beispiel: |
    c = getc(fp);
    /* weist c das nächste Zeichen aus der Datei zu */

## getchar

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int getchar(void);`
Rückgabewert: | eingelesenes Zeichen, bei Fehler oder Dateiende EOF
Beschreibung: | Das Makro liest das nächste Zeichen von stdin
Beispiel: |
    c = getchar();
    /* weist c das nächste Zeichen von stdin zu */

## getenv

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `char *getenv(const char *name);`
Rückgabewert: | Zeiger auf den entsprechenden Eintrag; kein Name: NULL
Beschreibung: | Sucht in der Tabelle der Umgebungsvariablen nach dem zu `name` gehörenden Eintrag.
Beispiel: |
    ptr = getenv("PATH");
    /* weist ptr den Inhalt des "PATH"-Eintrages
    in der Umgebung zu */

## gets

Bibliothek: | `#include <stdio.h>`
Prototyp: | `char *gets(char *buffer);`
Rückgabewert: | Funktion liefert ihr Argument als Rückgabe, bei Fehler oder Dateiende NULL-Zeiger
Beschreibung: | Liest eine Textzeile bis zum Newline-Zeichen von `stdin` und schreibt sie in den durch `buffer` adressierten Speicherbereich. Newline wird durch "\0" ersetzt. Achtung: Gefahr des 'Buffer overflow', falls die Eingabezeile länger als der Puffer ist - besser `fgets()` verwenden.
Beispiel: |
    char buffer[100];
    gets(buffer);
    /* liest Textzeile in buffer ein */

## gmtime

Bibliothek: | `#include <time.h>`
Prototyp: | `struct tm *gmtime(const time_t *sec);`
Rückgabewert: | Zeiger auf Struktur vom Typ `tm`
Beschreibung: | Wandelt die mit `sec` angegebene Anzahl von Sekunden, die seit der UNIX-Epoche (1.1.1970 0 Uhr GMT) vergangen sind, in das entsprechende Datum um (GMT = Greenwich Mean Time). Die Ortszeit-Struktur `struct tm` hat folgende Elemente: `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
Beispiel: |
    time_t sec;
    time(&sec);
    printf("GMT: %s\n", asctime(gmtime(&sec)));

## isalnum

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int isalnum(int c);`
Rückgabewert: | alphanumerisches Zeichen: Wert ungleich 0; andernfalls 0
Beschreibung: | Das Makro überprüft, ob das Zeichen in c ein alphanumerisches Zeichen ist, d.h. ein Buchstabe oder eine Ziffer des zugrundeliegenden Alphabets (Zeichen 0 bis 127 im ASCII).
Beispiel: |
    if (isalnum(c))
      printf("%c ist alphanumerisch\n",c);

## isalpha

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int isalpha(int c);`
Rückgabewert: | kein Buchstabe: 0; Buchstabe: Wert ungleich 0
Beschreibung: | Das Makro prüft ob das Zeichen c ein Buchstabe des zugrundeliegenden Alphabets ist (ASCII ohne Umlaute).
Beispiel: |
    if (isalpha(c))
      printf("%c ist ein Buchstabe\n",c);

## iscntrl

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int iscntrl(int c);`
Rückgabewert: | Steuerzeichen: Wert ungleich 0; andernfalls : 0
Beschreibung: | Das Makro prüft, ob das Zeichen c ein Steuerzeichen ist (Zeichen 0 bis 31 oder 127 in ASCII).
Beispiel: |
    if (iscntrl(c))
      printf("Steuerzeichen\n");

## isdigit

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int isdigit(int c);`
Rückgabewert: | Ziffer: Wert ungleich 0; andernfalls 0
Beschreibung: | Das Makro prüft, ob das Zeichen c eine Ziffer (0, 1, ..., 9) ist.
Beispiel: |
    if (isdigit(c))
      printf("%c ist eine Ziffer\n", c);

## isgraph

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int isgraph(int c);`
Rückgabewert: | grafisches Zeichen: Wert ungleich 0; andernfalls 0
Beschreibung: | Das Makro prüft, ob das Zeichen c ein druckbares Zeichen, aber kein Leerzeichen ist (Zeichen 33 bis 126 in ASCII - wie `isprint` ohne Leerzeichen).
Beispiel: |
    if (isgraph(c))
      printf("%c ist ein grafisches Zeichen\n",c);

## islower

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int islower (int c);`
Rückgabewert: | Kleinbuchstabe: Wert ungleich 0; andernfalls 0
Beschreibung: | Das Makro prüft, ob das Zeichen c ein Kleinbuchstabe ist (ASCII ohne Umlaute).
Beispiel: |
    if (islower(c))
      printf("%c ist ein Kleinbuchstabe\n",c);

## isprint

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int isprint(int c);`
Rückgabewert: | druckbares Zeichen: Wert ungleich 0; andernfalls 0
Beschreibung: | Das Makro prüft, ob das Zeichen c ein druckbares Zeichen ist (Zeichen 32 bis 127 im ASCII)
Beispiel: |
    if (isprint(c))
    printf("%c ist ein druckbares Zeichen\n",c);

## ispunct

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int ispunct(int c);`
Rückgabewert: | Interpunktionszeichen: Wert ungleich 0; andernfalls 0
Beschreibung: | Das Makro prüft, ob das Zeichen c ein Interpunktionszeichen ist (alle druckbaren Zeichen und Leerzeichen ohne Ziffern und Buchstaben).
Beispiel: |
    if (ispunct(c))
      printf("%c ist ein Interpunktionszeichen",c);

## isspace

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int isspace (int c);`
Rückgabewert: | Leerzeichen: Wert ungleich 0; andernfalls 0
Beschreibung: | Das Makro prüft, ob das Zeichen c ein "Whitespace"-Zeichen ist, d. h. horizontaler oder vertikaler Tabulator, Newline, Formfeed (Seitenvorschub), Carriage-Return oder Leerzeichen.
Beispiel: |
    if (isspace(c))
      printf("%c ist ein Leerzeichen\n",c);

## isupper

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int isupper(int c);`
Rückgabewert: | Großbuchstabe: Wert ungleich 0; andernfalls 0
Beschreibung: | Das Makro prüft, ob das Zeichen c ein Großbuchstabe ist (ASCII ohne Umlaute).
Beispiel: |
    if (isupper(c))
      printf("%c ist ein Großbuchstabe\n",c);

## isxdigit

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int isxdigit(int c);`
Rückgabewert: | Hexadezimalziffer: Wert ungleich 0; andernfalls 0
Beschreibung: | Das Makro prüft, ob das Zeichen c eine Hexadezimalziffer ist (0 bis 9, a bis f und A bis F)
Beispiel: |
    if (isxdigit(c))
      printf("%c ist eine Hexadezimalziffer\n",c);

## labs

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `long labs(long x);`
Rückgabewert: | | x |
Beschreibung: | Liefert den Absolutwert des long-Wertes x
Beispiel: |
    printf("labs(-9876543) = %ld",labs(-9876543));
    /* Ausgabe: labs(-9876543) = 9876543 */

## ldexp

Bibliothek: | `#include <math.h>`
Prototyp: | `double ldexp(double m, int exp);`
Rückgabewert: | m * 2; bei Überlauf `HUGE_VAL` mit Vorzeichen
Beschreibung: | Berechnet den Wert m * 2; im Falle eines Überlauf erhält `errno` den Wert `ERANGE`
Beispiel: |
    printf("ldexp(3.0,4) = %.1f",ldexp(3.0,4));
    /* Ausgabe: ldexp(3.0,4) = 48 */

## ldiv

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `ldiv_t ldiv(long x, long y);`
Rückgabewert: | Struktur von Typ `ldiv_t`
Beschreibung: | Dividiert die beiden long-Werte x/y, dabei werden der ganzzahlige Anteil des Ergebnisses und der Rest in einer Variablen vom Typ `ldiv_t` abgelegt. `ldiv_t` wird in `stdlib.h` definiert.
Beispiel: |
    ldiv_t result;
    result = ldiv(1000000,45000);
    printf("ldiv(1000000,45000) = %ld Rest %ld",
           result.quot,result.rem);
    /* Ausgabe: ldiv(1000000,45000) = 22 Rest 10000 */

## localtime

Bibliothek: | `#include <time.h>`
Prototyp: | `struct tm *localtime(const time_t *sec);`
Rückgabewert: | Zeiger auf Struktur vom Typ `tm`
Beschreibung: | Wandelt die Anzahl der Sekunden (sec) seit 1.1.1970 0 Uhr in das lokale Datum und Uhrzeit um `time_t` ist in time.h als `long` definiert. Die Ortszeit-Struktur `struct tm` hat folgende Elemente: `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
Beispiel: |
    struct tm *zeit;
    time_t sec;
    time(&sec);
    printf("Datum/Uhrzeit: %s\n",
           asctime(localtime(&sec)));
    /* das lokale Datum und Uhrzeit wird ausgegeben */

## log

Bibliothek: | `#include <math.h>`
Prototyp: | `double log(double x);`
Rückgabewert: | ln(x); bei Argument <= 0: `HUGE_VAL`
Beschreibung: | Liefert den natürlichen Logarithmus von x bei negativen Argumenten erhält `errno` den Wert `EDOM`. Ist x = 0 so erhält `errno` jedoch `ERANGE`.
Beispiel: |
    printf("ln(0.5) = %7.4f\n",log(0.5));
    /* Ausgabe: ln(0.5) = -0.6931 */

## log10

Bibliothek: | `#include <math.h>`
Prototyp: | `double log10(double x);`
Rückgabewert: | lg(x); bei Argument <= 0: `HUGE_VAL`
Beschreibung: | Liefert den dekadischen Logarithmus von x. Bei negativen Argumenten erhält `errno` den Wert `EDOM`, ist x = 0 so erhält `errno` den Wert `ERANGE`.
Beispiel: |
    printf("lg(10) = %4.1f\n", log10(10));
    /* Ausgabe: lg(10) = 1.0 */

## longjmp

Bibliothek: | `#include <setjmp.h>`
Prototyp: | `void longjmp(jmp_buf env, int retwert);`
Rückgabewert: | keiner
Beschreibung: | Ermöglicht Sprünge, die nicht an eine feste Zeile im Programm gebunden sind. Das Programm verzweigt zu der Stelle, an der zuvor die Funktion setjmp aufgerufen wurde. Der alte Maschinenzustand und die Stack-Umgebung, welche in env gespeichert sind, werden wiederhergestellt. `retwert` stellt einen Wert ungleich 0 dar (um von `setjmp` unterscheidbar zu sein). `jmp_buf` ist in `setjmp.h` definiert.
Beispiel: |
    jmp_buf env;
    int retwert;
    ...
    if (setjmp(env) == 0)
    printf("Zielmarke initialisiert\n");
    else printf("longjmp-Sprung erfolgt\n");
    ...
    longjmp(env,retwert);
    /* Ausgabe: Zielmarke initialisiert, wenn TRUE oder
    longjmp-Sprung erfolgt, wenn FALSE */

## malloc

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `void *malloc(size_t size);`
Rückgabewert: | typenloser Zeiger auf Startadresse des bereitgestellten Speichers; im Fehlerfall NULL-Zeiger
Beschreibung: | Reserviert einen Speicherbereich von `size` Bytes. `size_t` ist in `stdlib.h` als `unsigned int` definiert.
Beispiel: |
    int *feld
    feld = (int *) malloc(10*sizeof(int));

## memchr

Bibliothek: | `#include <string.h>`
Prototyp: | `void *memchr(const void *buffer, int c, size_t n);`
Rückgabewert: | Zeiger auf erstes Auftreten des Zeichens c im Puffer
Beschreibung: | Bestimmt in den ersten n Bytes des Puffers `buffer` das erste Auftreten des Zeichens c. `size_t` ist in string.h als `unsigned int` definiert.
Beispiel: |
    Zeiger = memchr(puffer,'!',55);
    /* Zeiger = Adresse des ersten Auftretens
    des Zeichens '!' in den vorderen 55 Bytes
    des Puffers */

## memcmp

Bibliothek: | `#include <string.h>`
Prototyp: | `int memcmp(const void *buf1, const void *buf2, size_t n);`
Rückgabewert: | < 0, wenn buf1 "kleiner" buf2 ist = 0, wenn beide identisch sind > 0, wenn buf1 "größer" als buf2 ist
Beschreibung: | Vergleicht die ersten n Bytes des Puffers `buf1` mit denen des `buf2`. Der Vergleich bricht beim ersten verschiedenen Zeichen ab. `size_t` ist in `string.h` als `unsigned int` definiert.
Beispiel: |
    if (memcmp(s1,s2,20) != 0)
      printf("Strings sind ungleich\n");
    else
      printf("Strings sind gleich\n");

## memcpy

Bibliothek: | `#include <string.h>`
Prototyp: | `void *memcpy(void *dest, const void *src, size_t n);`
Rückgabewert: | Zeiger auf `dest`
Beschreibung: | Kopiert Anzahl n Bytes von der Quelle `src` zum Ziel `dest`. `size_t` ist in `string.h` als `unsigned int` definiert. Im Unterschied zu `memmove` wird bei einer eventuellen Überlappung der Speicherbereiche nicht sichergestellt, daß zuerst gelesen und dann geschrieben wird.
Beispiel: |
    zeiger = memcpy(ziel,quelle,100);
    /* kopiert 100 Bytes von quelle nach ziel,
    zeiger erhält die Adresse von ziel */

## memmove

Bibliothek: | `#include <string.h>`
Prototyp: | `void *memmove(void *dest, const void *src,size_t n);`
Rückgabewert: | Zeiger auf `dest`
Beschreibung: | Kopiert n Bytes von `src` nach `dest`. `size_t` ist in `string.h` als `unsigned int` definiert. Im Unterschied zu `memcpy` wird bei einer eventuellen Überlappung der Speicherbereiche zuerst gelesen und dann überschrieben.
Beispiel: |
    zeiger = memmove(ziel,quelle,30);
    /* kopiert 30 Bytes von quelle nach ziel,
    zeiger erhält die Adresse von ziel */

## memset

Bibliothek: | `#include <string.h>`
Prototyp: | `void memset(void *dest, int c, `unsigned int` n);`
Rückgabewert: | Zeiger auf `dest`
Beschreibung: | Füllt die ersten n Bytes von `dest` mit dem Wert von c
Beispiel: |
    memset(s,' ',strlen(s));
    /* der String wird mit Leerzeichen überschrieben */

## mktime

Bibliothek: | `#include <time.h>`
Prototyp: | `time_t mktime(struct tm *ptr);`
Rückgabewert: | Anzahl der Sekunden; im Fehlerfall -1
Beschreibung: | Wandelt die durch den Zeiger `ptr` adressierten Zeitangaben in die Anzahl von Sekunden seit dem 1.1.1970 0 Uhr um. Die Ortszeit-Struktur `struct tm` hat folgende Elemente: `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
Beispiel: |
    time_t heute;
    struct tm *morgen;
    time(&heute);
    morgen = localtime(&heute);
    morgen->tm_mday += 1;
    if (mktime(morgen) != -1)
      printf("Morgen ist: %s\n",asctime(&zukunft));
    else
      printf("Fehler bei mktime()");

## modf

Bibliothek: | `#include <math.h>`
Prototyp: | `double modf(double x, double *intpart);`
Rückgabewert: | gebrochener Anteil von x
Beschreibung: | Spaltet Fließkommazahl x in einen gebrochen-rationalen und einen ganz-rationalen Teil auf, welcher in `intpart` gespeichert wird.
Beispiel: |
    gebr = modf(3.432,&ganz);
    printf("gebr = %f, ganz = %d\n",gebr,ganz);
    /* Ausgabe: gebr = 0.432, ganz = 3 */

## opendir

Bibliothek: | `#include <dirent.h>` `#include <sys/types.h>`
Prototyp: | `DIR *opendir (const char *name);`
Rückgabewert: | im Erfolgsfall Zeiger auf eine DIR-Struktur, im Fehlerfall NULL-Pointer.
Beschreibung: | Öffnet ein Verzeichnis und richtet einen Verzeichnis-Stream ein. Der zurückgelieferte Zeiger dient zum Lesen der Verzeichnisinformation mittels `readdir()`.
Beispiel: |
    dir = opendir("/var/log/");

## perror

Bibliothek: | `#include <stdio.h>`
Prototyp: | `void perror(const char *string);`
Rückgabewert: | keiner
Beschreibung: | Sendet Fehlermeldung zur Standardfehlerausgabe `stderr`, zuerst wird `string` ausgegeben, dann ": " und anschließend der Systemfehler.
Beispiel: |
    perror("Hilfe");
    /* erzeugt eine Fehlermeldung der Art:
    "Hilfe: bla bla bla" */

## popen

Bibliothek: | `#include <stdio.h>`
Prototyp: | `FILE *popen(const char *command, const char *type);`
Rückgabewert: | File-Pointer; im Fehlerfall NULL
Beschreibung: | Öffnet eine Pipe zum angegebenen Programm `command` in der Zugriffsart `type`. `command` ist ein nullterminierter String, der ein Kommando enthält. Dieses wird an die Shell zur Ausführung übergeben (→ `/bin/sh -c command`). `FILE` ist in `stdio.h` definiert. `type` ist ein nullterminierter String, der den Modus angibt (lesend oder schreibend):
"r" | Lesen (Verarbeiten der Standardausgabe von `command`)
"w" | Schreiben (Schreiben in die Standardeingabe von `command`)
Beispiel: |
    fp = popen("ps ax","r");
    /* liest die Ausgabe des Kommandos "ps ax" */

## pclose

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int pclose(FILE *stream);`
Rückgabewert: | Return-Wert des aufgerufenen Programms; im Fehlerfall -1
Beschreibung: | Schließt eine vorher geöffnete Pipe. Die Funktion wartet, bis der Prozess beendet wurde.
Beispiel: |
    retval = pclose(fp);
    /* schliesst die Verbindung zur Pipe */

## pow

Bibliothek: | `#include <math.h>`
Prototyp: | `double pow(double x,double y);`
Rückgabewert: | xy bei Unter- oder Überlauf: `+/-HUGE_VAL` bei unzulässigen Argumenten: 0
Beschreibung: | Berechnet xy. Bei Unter-/Überlauf erhält `errno` den Wert `ERANGE`. Falls die Argumente nicht im Definitionsbereich liegen, wird eine entsprechende Fehlermeldung auf `stderr` ausgegeben. `errno` erhält den Wert `EDOM`.
Beispiel: |
    printf("pow(2.0,2.0) = %4.1f\n",pow(2.0,2.0));
    /* Ausgabe: pow(2.0,2.0) = 4.0 */

## printf

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int printf(const char *formatstring,..., [arg1,...,argn]);`
Rückgabewert: | Anzahl der ausgegebenen Zeichen; im Fehlerfall EOF
Beschreibung: | Gibt `formatstring` auf `stdout` aus. Formatelemente werden durch Werte aus der Argumentenliste ersetzt. Ein Formatelement bestimmt die Interpretation des Arguments folgendermaßen: `% [Flags] [Feldbreite] [.Genauigkeit] Typ` Flags: '+' positive Zahlen mit Vorzeichen ' ' positive Zahlen mit führendem Leerzeichen '-' linksbündige Ausgabe Feldbreite: Länge des Ausgabefeldes (Ausgabe > Feld: Feld wird vergrößert). Bei Zahlen werden führende Leerzeichen mit Nullen aufgefüllt. Wird als Feldbreite '*' angegeben, bestimmt ein zusätzliches Argument vom Typ int die Feldbreite. Genauigkeit: Anzahl der Ziffern hinter dem Dezimalpunkt bei Ausgaben vom Typ f oder e. Anzahl der signifikanten Stellen bei Ausgaben mit g. Mindestzahl an auszugebenden Ziffern bei Ganzzahl-Ausgabe Höchstzahl der auszugebenden Zeichen bei Stringausgabe. Typ: gibt Interpretationsart für das Argument an; folgenden Angaben sind möglich
c | Zeichen(-folge) (auch blanks, tabs und newlines werden gelesen) Default (keine Feldgrößenangabe): 1 Zeichen
d | Integer (dezimal)
i | Integer (dezimal) oder oktal (mit führender "0") oder sedezimal (mit führendem "0x" bzw "0X")
o | Integer (oktal, mit oder ohne führende "0")
x | Integer (sedezimal, mit oder ohne führendem "0x" bzw "0X")
u | Integer (dezimal, nur positiv)
e, f, g | Gleitpunktzahl (beliebige Darstellung)
s | String (Ergänzung mit abschließendem '\0')
p | Pointer
h vor d,i,o,u,x | Kurze Integerzahl (short)
l vor d,i,o,u,x | Lange Integerzahl (long)
l vor e,f,g | double
L vor e,f,g | long double
Beispiel: | `printf()` wird bei den meisten Beispielen verwendet.

## putc

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int putc(int c, FILE *fp);`
Rückgabewert: | ausgegebenes Zeichen; Im Fehlerfall EOF
Beschreibung: | Das Makro schreibt das Zeichen c auf die aktuelle Position der Datei
Beispiel: |
    putc(c,fp);
    /* schreibt das Zeichen c an die aktuelle Position
    der Datei, die mit fp verbunden ist */

## putchar

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int putchar(int c);`
Rückgabewert: | ausgegebenes Zeichen; Im Fehlerfall EOF
Beschreibung: | Das Makro schreibt das Zeichen c auf die Standardausgabe. (putc(c,stdout) ist wirkungsgleich zu putchar(c)).
Beispiel: |
    putchar(c); /* gibt das Zeichen c über stdout aus */

## puts

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int puts(const char *string);`
Rückgabewert: | nicht negativer Wert; im Fehlerfall EOF
Beschreibung: | Schreibt den String `string` auf die Standardausgabe stdout, abschließend wird ein Newline-Zeichen ausgegeben.
Beispiel: |
    puts("Hello World!");

## qsort

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `void qsort(void *array, size_t n, size_t size, int (*compare)());`
Rückgabewert: | keiner
Beschreibung: | Sortiert das Feld `array` aufsteigend mit dem Quick-Sort-Algorithmus, wobei das Feld n Elemente der Größe `size` besitzt. `size_t` ist in `stdlib.h` als `unsigned int` definiert.`compare` ist ein Zeiger auf eine Vergleichsfunktion, der Zeiger auf 2 Feldelemente übergeben werden (Argumente von `compare` müssen Zeiger auf den Typ der Feldelemente sein). `compare` liefert Rückgabewerte folgender Art: kleiner 0 : 1. Element < 2. Element gleich 0 : 1. Element = 2. Element größer 0 : 1. Element > 2. Element
Beispiel: |
    #define MAX 1000
    ...

     int intcmp(const void *v1, const void *v2)
       { return (*(int *)v1 - *(int *)v2); }

    main()
      {
      int arr[MAX], count, suche, *zgr;
      ...

      /* Sortiert das Array in aufsteigender Reihenfolge. */
      qsort(arr, MAX, sizeof(arr[0]), intcmp);
      ...

      }

## raise

Bibliothek: | `#include <signal.h>`
Prototyp: | `int raise(int sig);`
Rückgabewert: | erfolgreiche Ausführung: 0; andernfalls Wert ungleich 0
Beschreibung: | Sendet ein Signal `sig` zum ausführenden Programm. Ist mit der Funktion `signal` eine Behandlungsfunktion für die Nummer des Signals festgelegt worden, so wird diese ausgeführt, andernfalls wird die Standardroutine verwendet.

## rand

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `int rand(void);`
Rückgabewert: | Zufallszahl
Beschreibung: | Liefert eine Pseudo-Zufallszahl, die zwischen 0 und `RAND_MAX` liegt. `RAND_MAX` ist in `stdlib.h` definiert und hat mindestens den Wert 32767. Die Initialisierung erfolgt mit `srand`.

## readdir

Bibliothek: | `#include <dirent.h>` `#include <sys/types.h>`
Prototyp: | `struct dirent readdir (DIR *dirp);`
Rückgabewert: | im Erfolgsfall Zeiger auf eine Stuktur mit dem nächsten Verzeichniseintrag, im Fehlerfall und am Ende des Verzeichnisses NULL-Zeiger
Beschreibung: | Liefert einen Zeiger auf eine Stuktur mit dem nächsten Verzeichniseintrag. Nacheinanderfolgende Aufrufe liefern den jeweils folgenden Verzeichniseintrag. Die Struktur `dirent` hat selbst folgende Einträge: `ini_t d_ino`: die Inode-Nummer der Datei/des Verzeichnisses `char d_name[]`: der Name der Datei/des Verzeichnisses
Beispiel: |
    DIR * dp;
    struct dirent *entry;
    dp = opendir("/var/log/");
    while ((entry = readdir(dp)) != NULL)
      {
      printf("*s\n",entry->d_name);
      }
    closedir(dp);

## realloc

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `void *realloc(void *ptr, `size_t` n);`
Rückgabewert: | typenloser Zeiger auf zugewiesenen Speicher; im Fehlerfall NULL-Zeiger
Beschreibung: | Verändert die Größe des durch `ptr` bezeichneten Speicherbereichs, der zuvor durch `malloc`, `calloc` oder `realloc` reserviert wurde.`n` ist die Länge des neuen Speicherbereiches `size_t` ist in `stdlib.h` als `unsigned int` definiert. Die Daten im bereits zugewiesenen Bereich bleiben unverändert.
Beispiel: |
    realloc(zeiger,anzahl*sizeof(typ));

## remove

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int remove(const char *filename);`
Rückgabewert: | Im Fehlerfall Wert ungleich 0; andernfalls 0
Beschreibung: | Die unter `filename` angegebene Datei läßt sich nicht mehr unter ihrem Namen ansprechen, verfügt sie über keine weiteren Dateiverweise (Links), so wird sie gelöscht (-> unlink). Verzeichnisse oder read-only-Dateien können nicht gelöscht werden. Bei Fehlern erhält `errno` den Wert `EACCES` bzw. `ENOENT`.
Beispiel: |
    remove("bsp.txt");
    /* löscht die Datei 'bsp.txt' */

## rename

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int rename(const char *altname, const char *neuname`);
Rückgabewert: | 0; im Fehlerfall Wert ungleich 0
Beschreibung: | Benennt die Datei`altname` in `neuname` um. `altname` muß bereits existieren. Eintrag von `neuname` in ein anderes Verzeichnis ist möglich, nicht jedoch Eintrag in ein anderes Dateisystem (wie das UNIX mv-Kommando).
Beispiel: |
    rename("/home/meier/bsp.c","/home/meier/src/bsp1.c");

## rewind

Bibliothek: | `#include <stdio.h>`
Prototyp: | `void rewind(FILE *fp);`
Rückgabewert: | keiner
Beschreibung: | Setzt den Seek-Zeiger der Datei auf den Dateianfang zurück, löscht das Dateiende-Flag und das Fehler-Flag
Beispiel: |
    rewind(fp);

## scanf

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int scanf(const char *formatstring,...,` [arg1,...,argn]);
Rückgabewert: | Anzahl der tatsächlich eingelesenen und konvertierten Eingabefelder; bei Lesefehler oder Dateiende: EOF
Beschreibung: | Liest Zeichen in formatierter Form von der Standardeingabe `stdin` ein und legt sie konvertiert in den Argumenten `arg1` bis `argn` ab. Die Interpretation der eingelesenen Zeichen erfolgt durch den Format-String `formatstring`. Für jedes Formatelement des Strings muß ein Argument angegeben sein (überzählige werden ignoriert). Die Formatelemente haben folgende Form: `% [Feldbreite] Typ` (siehe auch `printf`). Eingabefelder werden durch Leerzeichen getrennt wird mit Typ s ein String eingelesen, so wird ein Stringende-Zeichen angehängt anstelle von s kann auch ein Scanset (Folge von sog. Suchzeichen) angegeben werden, welcher in eckige Klammern eingeschlossen wird; jedes einzulesende Zeichen muß dann mit einem der Suchzeichen übereinstimmen. Ist den Suchzeichen ein '^' vorangestellt, wird das Einlesen beendet, sobald ein Suchzeichen auftritt. steht hinter '%' ein '*', wird das entsprechende Eingabefeld überlesen. Es darf kein Argument angegeben werden.

## seekdir

Bibliothek: | `#include <dirent.h>` `#include <sys/types.h>`
Prototyp: | `void seekdir (DIR *dirp, long int pos);`
Rückgabewert: | -
Beschreibung: | Setzt im Verzeichnis-Stream den Positionszeiger auf die durch `pos` gegebene Stelle. Der Wert von `pos` wird durch einen vorhergehenden Aufruf von `telldir` ermittelt. Man kann sich so eine Stelle beim sequentiellen Lesen eines Verzeichnisses merken und später dorthin zurückspringen.
Beispiel: |
    pos = telldir(dir);
    /* ... */
    seekdir(dir,pos);

## setbuf

Bibliothek: | `#include <stdio.h>`
Prototyp: | `void setbuf(FILE *fp, char *buffer);`
Rückgabewert: | keiner
Beschreibung: | Richtet für die mit dem Dateizeiger verbundene Datei den Dateipuffer `buffer` mit Länge `BUFSIZ` ein. `BUFSIZ` ist in `stdio.h` definiert. Falls `buffer` ein NULL-Zeiger ist, ist die Ein-/Ausgabe ungepuffert. `setbuf` muß sofort nach dem Öffnen der Datei aufgerufen werden.
Beispiel: |
    char puffer[BUFSIZ];
    setbuf(fp,puffer);

## setjmp

Bibliothek: | `#include <setjmp.h>`
Prototyp: | `int setjmp(jmp_buf env);`
Rückgabewert: | 0; bei Rücksprung durch longjmp wird dieser auf einen Wert ungleich 0 gesetzt
Beschreibung: | Speichert den momentanen Maschinenzustand und die Stack-Umgebung in `env`. `jmp_buf` ist in `setjmp.h` definiert. Durch späteren `longjmp`-Aufruf wird der gespeicherte Zustand wiederhergestellt.
Beispiel: |
    setjmp(env);

## setvbuf

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int setvbuf (FILE *fp,char *buf,int mode,size_t size);`
Rückgabewert: | Im Fehlerfall Wert ungleich 0; sonst: 0
Beschreibung: | Legt für die Datei anstelle des standardmäßigen Dateipuffers einen Puffer der Länge `size`. Für den Parameter `mode` sind in `stdio.h` folgende symbolische Konstanten definiert: `_IOFBF`: Ein-/Ausgabe werden vollständig gepuffert `_IOLBF`: Ausgaben werden zeilenweise gepuffert, Eingaben werden vollständig gepuffert `_IONBF`: Ein-/Ausgaben sind ungepuffert Falls `buffer` ein NULL-Zeiger ist, so wird durch einen Aufruf von `malloc` ein Puffer der Größe `size` dynamisch angelegt
Beispiel: |
    setvbuf(fp,buffer,_IONBF,sizeof(buffer);
    /* setzt für die mit fp verbundene Datei
    ungepufferte Ein-/Ausgabe (buffer und
    sizeof(buffer) werden ignoriert) */

## signal

Bibliothek: | `#include <signal.h>`
Prototyp: | `void (*signal (int sig, void (*func)(int)))(int);`
Rückgabewert: | Im Fehlerfall `SIG_ERR`; beim erster Aufruf `SIG_DFL`; sonst den Wert von `func` aus dem vorhergehenden Aufruf.
Beschreibung: | Legt fest, wie das Programm auf Signale mit der Signalnummer `sig` reagiert. Das Argument func legt die Art der Reaktion fest. Folgende Möglichkeiten sind vorhanden: SIG_DFL: Standardroutine (default) für die Signalnummer wird aufgerufen; danach im allgemeinen Programmende SIG_IGN: Signal wird ignoriert, das Programm fortgesetzt Adresse einer Funktion: `signal(sig,SIG_DFL)` wird aufgerufen, dann die Funktion `(*func)(sig)` (für nächstes `sig` wird die Standardroutine eingesetzt, dann die eigentliche Reaktion auf das momentane Signal ausführt). Folgende Signaltypen sind nach ANSI-Standard in `signal.h` definiert: SIGABRT: abnormale Programmbeendigung (z.B. durch abort; Beenden des Programms) SIGHUB: Programmbeendigung durch Elternprozess SIGFPE: Divisions-,Coprozessor- oder Emulationsfehler SIGINT: durch Drücken von Ctrl-C SIGSEGV: durch ungültigen Speicherzugriff SIGTERM: Software-Beendigung des Programms (unter UNIX Standardsignal des Kill-Kommandos) Bei Fehlern erhält `errno` den Wert `EINVAL`.
Beispiel: |
    #include <stdio.h>
    #include <stdlib.h>
    #include <signal.h>
    void sig_handler(int sig);
    main()
      {
      if (signal(SIGINT,sig_handler) == SIGERR)
        { perror("Signal-Funktion"); exit(3); }
      for(;;) /* forever */
        puts("Abbruch mit Strg-C!\n");
      }

    void sig_handler(int sig)
      {
      char c;
      if (sig != SIGINT) exit(1);
      signal(SIGINT,SIG_IGN);
      fputs("\nProgramm beenden(j/n)?",stderr);
      while((c = toupper(getchar())) != 'J' && c != 'N');
      if(c == 'J') exit(0);
      signal(SIGINT,sig_handler);
      }

## sin

Bibliothek: | `#include <math.h>`
Prototyp: | `double sin(double x);`
Rückgabewert: | sin(x)
Beschreibung: | Liefert den Sinus von x. Die Angabe erfolgt im Bogenmaß. Das Argument x wird durch Modulo-Division in den Bereich von 0 bis 2*Pi umgerechnet (Ungenauigkeit bei großen Argumenten).
Beispiel: |
    printf("sin(0.0) = %4.1f\n", sin(0.0));
    /* Ausgabe: sin(0.0) = 0.0 */

## sinh

Bibliothek: | `#include <math.h>`
Prototyp: | `double sinh(double x);`
Rückgabewert: | sinh(x); bei Überlauf: `HUGE_VAL`
Beschreibung: | Liefert den Sinus Hyperbolicus von x. Bei einem Überlauf erhält `errno` den Wert `ERANGE`.
Beispiel: |
    printf("sinh(0.0) = 8.4f\n",sinh(0.0));
    /* Ausgabe: sinh(0.0) = 0.0000 */

## sprintf

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int sprintf(char *string,const char *formatstring, [arg1,...,argn]);`
Rückgabewert: | Anzahl der Zeichen, die in den String kopiert wurden (ohne Stringende-Zeichen)
Beschreibung: | Kopiert entsprechend dem `formatstring` mit den Werten aus der Argumentliste formatiert in den String `string` (Stringende-Zeichen wird angehängt). Arbeitsweise wie `printf`, jedoch ist das Zeil der Ausgabe keine Datei, sondern ein String.
Beispiel: |
    sprintf(text,"%15s %20s",vorname,name);

## sqrt

Bibliothek: | `#include <math.h>`
Prototyp: | `double sqrt(double x);`
Rückgabewert: | Quadratwurzel von x
Beschreibung: | Liefert die Quadratwurzel von x. Falls x negativ ist, erhält `errno` den Wert `ERANGE`
Beispiel: |
    printf("sqrt(9) = %f\n",sqrt(9));
    /* Ausgabe: sqrt(9) = 3.0 */

## srand

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `void srand(unsigned n);`
Rückgabewert: | keiner
Beschreibung: | Initialisiert den Zufallszahlengenerator mit n; anschließend erzeugt rand eine neue Folge von Zufallszahlen
Beispiel: |
    srand(5); /* initialisiert den Generator mit 5 */

## sscanf

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int sscanf(char *string,const char *formatstring, ... [arg1,...,argn]);`
Rückgabewert: | Anzahl der tatsächlich übertragenen Eingabefelder; Stringende-Zeichen : EOF
Beschreibung: | Liest und konvertiert Daten aus dem String `string` und schreibt sie in die durch die Argumentliste bezeichneten Variablen
Beispiel: |
    sscanf(adresse,"%[^,],%[^,],%d",ort, straße, &hausnr);
    /* liest aus dem String adresse:
    1. Teilstring (bis zu einem Komma) in  ort,
    2. Teilstring (bis zu einem Komma) in straße
    und den Rest (eine Zahl) in hausnr */

## strcat

Bibliothek: | `#include <string.h>`
Prototyp: | `char *strcat(char *s1,const char *s2);`
Rückgabewert: | erstes Argument
Beschreibung: | Kettet den String `s2` an das Ende des Strings `s1` (Stringende-Zeichen von `s1` wird überschrieben). `s1` muß `s2` aufnehmen können.
Beispiel: |
    strcat(s1,s2); /* hängt s2 an s1 an */

## strchr

Bibliothek: | `#include <string.h>`
Prototyp: | `char *strchr(const char *s,int c);`
Rückgabewert: | Zeiger auf Stelle des 1. Auftretens von `c` im String `s`; nicht vorhanden: NULL-Zeiger
Beschreibung: | Sucht nach dem 1. Auftreten des Zeichens c im String s
Beispiel: |
    P = strchr(text,'.');
    /* sucht im String text nach dem ersten
    Auftreten eines Punktes */

## strcmp

Bibliothek: | `#include <string.h>`
Prototyp: | `int strcmp(const char *s1,const char *s2);`
Rückgabewert: | < 0: `s1` kleiner `s2` = 0: `s1` gleich `s2` > 0: `s1` größer `s2`
Beschreibung: | Vergleicht die Strings `s1` und `s2` lexikographisch
Beispiel: |
    x = strcmp("HALLO","hallo");
    /* Ergebnis: x = -32
    (da in ASCII die Kleinbuchstaben
    höheren Code haben) */

## strcpy

Bibliothek: | `#include <string.h>`
Prototyp: | `char *strcpy(char *s1,const char *s2);`
Rückgabewert: | s1
Beschreibung: | Kopiert `s2` in den von `s1` adressierten Speicher
Beispiel: |
    /* kopiert s2 in den Speicher von s1 */
    strcpy(s1,s2);

## strcspn

Bibliothek: | `#include <string.h>`
Prototyp: | `int strcspn(const char *s1,const char *s2);`
Rückgabewert: | Länge des Teilstrings
Beschreibung: | Liefert Länge des Teilstrings von `s1`, der keines der Zeichen von `s2` enthält
Beispiel: |
    x = strnspn("Das Ergebnis ist 5","0123456789");

## strerror

Bibliothek: | `#include <string.h>`
Prototyp: | `char *strerror(int errnr);`
Rückgabewert: | Zeiger auf Fehlermeldung
Beschreibung: | Liefert einen Zeiger auf die zur Zahl `errnr` gehörende Systemfehlermeldung zurück. Die Zahl `errnr` ist meist der in ``errno`` gespeicherte Wert.
Beispiel: |
    fehlertext = strerror(42);
    /* Ausgabe:
       'Protocol driver not attached' */

## strlen

Bibliothek: | `#include <string.h>`
Prototyp: | ``size_t` strlen(const char *s);`
Rückgabewert: | Länge des Strings
Beschreibung: | Liefert die Länge des Strings`s` (ohne Stringende-Zeichen). `size_t` ist in `string.h` als `unsigned int` definiert.
Beispiel: |
    x = strlen("Beispiel");
    /* Ergebnis: x = 8 */

## strncat

Bibliothek: | `#include <string.h>`
Prototyp: | `char *strncat(char *s1, const char *s2, `size_t` n);`
Rückgabewert: | s1
Beschreibung: | Hängt die ersten `n` Zeichen des Strings `s2` und das Stringende-Zeichen an den String `s1` an. `size_t` ist in `string.h` als `unsigned int` definiert.
Beispiel: |
    char s1[20] = "Hello ";
    char s2[10] = "Worldwide";
    strncat(s1,s2,5);
    /* Ergebnis: 'Hello World' */

## strncmp

Bibliothek: | `#include <string.h>` NT FACE="Courier" SIZE=2> int strncmp(const char *s1,const char *s2,`size_t` n);
Rückgabewert: | < 0 falls s1 < s2; = 0 falls s1 = s2 > 0 falls s1 > s2
Beschreibung: | Vergleicht die ersten`n` Zeichen von`s1` und `s2`. Der Vergleich wird beim ersten Stringende-Zeichen abgebrochen
Beispiel: |
    strncmp(s1,s2,10);

## strncpy

Bibliothek: | `#include <string.h>`
Prototyp: | `char *strncpy(char *s1,const char *s2, `size_t` n);`
Rückgabewert: | s1
Beschreibung: | Kopiert die ersten`n` Zeichen von `s2` in den durch `s1` bezeichneten Speicherbereich. Das Stringende-Zeichen wird nicht angehängt. Ist `s2` kleiner als `n` wird mit '\0' aufgefüllt.
Beispiel: |
    strncpy(s1,"Testphase",4);

## strpbrk

Bibliothek: | `#include <string.h>`
Prototyp: | `char *strpbrk(const char *s1,const char *s2);`
Rückgabewert: | Zeiger auf erstes in `s1` mit `s2` übereinstimmendes Zeichen
Beschreibung: | Durchsucht `s1` nach einem der in `s2` enthaltenen Zeichen.
Beispiel: |
    zeiger = strpbrk("Blumenweg 3","1234567890");
    /*                   zeiger ^              */

## strrchr

Bibliothek: | `#include <string.h>`
Prototyp: | `char *strrchr(const char *s,int c);`
Rückgabewert: | Zeiger auf letztes Auftreten von Zeichen `c` in String `s`; falls `c` in `s` nicht vorkommt, der NULL-Zeiger.
Beschreibung: | Sucht nach letztem Auftreten des Zeichens `c` im String `s`
Beispiel: |
    P = strchr(text,'.');
    /* sucht im String text nach dem letzten
    Auftreten eines Punktes */

## strcspn

Bibliothek: | `#include <string.h>`
Prototyp: | `int strspn(const char *s1,const char *s2);`
Rückgabewert: | Länge des Teilstrings aus `s1`, der nur Zeichen aus `s2` enthält
Beschreibung: | Ermittelt Länge des Teilstrings von `s1`, der nur aus in `s2` enthaltenen Zeichen besteht.
Beispiel: |
    laenge = strspn("4500 Naegel","1234567890");
    /* Ergebnis: laenge = 4 */

## strstr

Bibliothek: | `#include <string.h>`
Prototyp: | `char *strstr(const char *s1,const char *s2);`
Rückgabewert: | Adresse des ersten Auftretens; ist s2 in s1 nicht enthalten: NULL-Zeiger
Beschreibung: | Sucht im String s1 nach s2
Beispiel: |
    puts(strstr("Heute ist es sehr heiß","sehr"));
    /* gibt 'sehr heiß' aus */

## strtod

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `double strtod(const char *s,char **endptr);`
Rückgabewert: | umgewandelte double-Zahl keine Umwandlung: 0 Überlauf: `+/- HUGE_VAL` Unterlauf: 0
Beschreibung: | Wandelt führende Zeichenfolge im String`s` in eine double-Zahl um; beim ersten nicht als Teil einer Gleitpunktzahl interpretierbaren Zeichen wird die Umwandlung abgebrochen. `endptr` wird auf das erste nicht mehr interpretierbare Zeichen gesetzt. Bei Über- bzw. Unterlauf erhält `errno` den Wert `ERANGE`.
Beispiel: |
    printf("Zahl: %f\n",strtod("200,5 Km",&rest));
    /* Ausgabe: Zahl: 200.5; rest zeigt auf 'Km' */

## strtok

Bibliothek: | `#include <string.h>`
Prototyp: | `char *strtok(char *s1,const char *s2);`
Rückgabewert: | Zeiger auf das nächste Token; kein weiteres Token: NULL-Zeiger
Beschreibung: | Zerlegt String `s1` in Token, die durch Zeichen aus `s2` voneinander getrennt sind. Beim ersten Aufruf muß `s1` angegeben werden, bei jedem weiteren dagegen 0. An jedes Token wird das Stringende-Zeichen '\0' angehängt (`s1` wird verändert!). `s2` kann bei jedem Aufruf verändert werden.
Beispiel: |
    zeiger1 = strtok("Hallo, wie geht es"," ");
    zeiger2 = strtok(0," ");
    /* zeiger1 zeigt auf 'Hallo,'
       zeiger2 zeigt auf 'wie' */

## strtol

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `long strtol(const char *s,char **endptr,int base);`
Rückgabewert: | umgewandelte long-Zahl keine Umwandlung: 0; Überlauf: `LONG_MIN` bzw. `LONG_MAX`
Beschreibung: | Die Zeichenfolge `s` wird in eine long-Zahl konvertiert; die Zeichenfolge wird als Zahl zur Basis `base` interpretiert. Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung beendet. `endptr` zeigt auf das erste nicht interpretierbare Zeichen bei einem Überlauf erhält `errno` den Wert `ERANGE`.
Beispiel: |
    x = strtol(10 Prozent",&rest,10);
    printf("***%ld*** %s\n",x,rest);
    /* Ausgabe: ***10*** Prozent */

## strtoul

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `unsigned long strtoul(const char *s,char **endptr,int base);`
Rückgabewert: | umgewandelte unsigned long-Zahl; keine Umwandlung: 0; Überlauf: ULONG_MAX
Beschreibung: | Wandelt die Zeichenfolge `s` in eine unsigned long-Zahl um (Zahl zur Basis `base`). Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung beendet `endptr` zeigt auf das erste nicht mehr interpretierbare Zeichen bei einem Überlauf erhält `errno` den Wert `ERANGE`.
Beispiel: |
    x = strtoul("2000 Autos",&rest,10)
    printf("Zahl : %ld\n", x);
    /* Ausgabe: 2000; rest zeigt auf den Reststring 'Autos' */

## system

Bibliothek: | `#include <stdlib.h>`
Prototyp: | `int system(const char *s);`
Rückgabewert: | NULL-Zeiger: Kommandointerpreter nicht verfügbar 0 bei korrekter Ausführung ungleich 0 bei einem Fehler
Beschreibung: | Erzeugt eine Shell als Kindprozess und führt dort den String`s` als Kommando des Betriebssystems aus. Die Bearbeitung erfolgt also wie ein am Prompt eingegebener Befehl. Der Befehl sollte immer als vollständiger Pfad angegeben werden.
Beispiel: |
    system("/bin/ls -l");
    /* Ausgabe des aktuellen Verzeichnisses */

## tan

Bibliothek: | `#include <math.h>`
Prototyp: | `double tan(double x);`
Rückgabewert: | tan(x); Argumentwert zu groß oder zu nah an den Polstellen: 0
Beschreibung: | Liefert den Tangens von x. Die Angabe erfolgt im Bogenmaß.
Beispiel: |
    printf("tan(1.0) = %7.4f\n",tan(1.0));
    /* Ausgabe: tan(1.0) = 1.5574 */

## tanh

Bibliothek: | `#include <math.h>`
Prototyp: | `double tanh(double x);`
Rückgabewert: | tanh(x)
Beschreibung: | Liefert den Tangens Hyperbolicus von x
Beispiel: |
    printf("tanh(2.0) = %7.4f\n",tanh(2.0));
    /* Ausgabe: tanh(2.0) = 0.9640 */

## telldir

Bibliothek: | `#include <dirent.h>` `#include <sys/types.h>`
Prototyp: | `long int telldir (DIR *dirp);`
Rückgabewert: | aktuelle Position im Verzeichnis-Stream.
Beschreibung: | Liest im Verzeichnis-Stream den aktuellen Positionszeiger `pos`. Man kann sich so eine Stelle beim sequentiellen Lesen eines Verzeichnisses merken und später mittels `seekdir()` dorthin zurückspringen.
Beispiel: |
    pos = telldir(dir);
    /* ... */
    seekdir(dir,pos);

## time

Bibliothek: | `#include <time.h>`
Prototyp: | `time_t time(time_t *ptr);`
Rückgabewert: | Anzahl der Sekunden
Beschreibung: | Liefert Anzahl der Sekunden seit der UNIX-Epoche (1.1.1970 0 Uhr GMT). Die Anzahl wird als Return-Wert zurückgeliefert und gleichzeitig in den durch `ptr` adressierten Speicher geschrieben. `time_t` ist in time.h als long definiert.
Beispiel: |
    time(&zeit);
    /* speichert die Anzahl der Sekunden
    seit dem 1.1.1970 0 Uhr in zeit */

## tmpfile

Bibliothek: | `#include <stdio.h>`
Prototyp: | `FILE *tmpfile(void)`
Rückgabewert: | Falls die Datei erfolgreich eröffnet wurde, der File-Pointer, sonst NULL-Zeiger.
Beschreibung: | Öffnet eine temporäre Datei im Binärmodus zum Schreiben und Lesen. Diese Datei wird automatisch bei Programmende oder beim Schließen gelöscht.
Beispiel: |
    fp = tmpfile();

## tmpnam

Bibliothek: | `#include <stdio.h>`
Prototyp: | `char *tmpnam(char *s);`
Rückgabewert: | Argument ist NULL-Zeiger: Zeiger auf den internen Puffer mit dem neuen Dateinamen Argument kein NULL-Zeiger: Zeichenkette s
Beschreibung: | Liefert einen neuen Dateinamen für eine temporäre Datei (verschieden von allen Dateinamen im aktuellen Verzeichnis). Ist `s` ein NULL-Zeiger, wird der erzeugte Dateiname in einem internen statischen Puffer abgelegt, der bei jedem neuen Aufruf überschrieben wird. Ist `s` kein NULL-Zeiger, so muß `s` auf einen char-Vektor zeigen, der mindestens `L_tmpnam` Bytes speichern kann (für Dateiname). Es können bis zu `TMP_MAX` verschiedene Namen erstellt werden. Die symbolischen Konstanten `TMP_MAX` und `L_tmpnam` sind in `stdio.h` definiert.
Beispiel: |
    tmpnam(name);

## tolower

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int tolower(int c);`
Rückgabewert: | umgewandeltes Zeichen
Beschreibung: | Konvertiert den in `c` gespeicherten Großbuchstaben in einen Kleinbuchstaben. Jedes andere Zeichen bleibt unverändert (nur ASCII-Zeichen 0 bis 127 betrachtet).
Beispiel: |
    gross = 'X';
    klein = tolower(gross);
    /* Ergebnis: 'x' */

## toupper

Bibliothek: | `#include <ctype.h>`
Prototyp: | `int toupper(int c);`
Rückgabewert: | umgewandeltes Zeichen
Beschreibung: | Konvertiert den in `c` gespeicherten Kleinbuchstaben in einen Großbuchstaben. Andere Zeichen bleiben unverändert (nur ASCII-Zeichen 0 - 127 betrachtet).
Beispiel: |
    klein = 'h';
    gross = toupper(klein);
    /* Ergebnis: 'H' */

## ungetc

Bibliothek: | `#include <stdio.h>`
Prototyp: | `int ungetc(int c, FILE *fp);`
Rückgabewert: | Zeichen `c`; Fehlerfall : EOF
Beschreibung: | Schreibt das Zeichen `c` wieder in den Dateipuffer zurück. Sollte ein EOF-Flag gesetzt sein, wird dieses gelöscht. Die nachfolgende Leseoperation beginnt mit dem Zeichen `c`. Die Datei muß zum Lesen geöffnet sein.
Beispiel: |
    ungetc(c,fp);

## va_arg

Bibliothek: | `#include <stdarg.h>`
Prototyp: | `type va_arg(va_list argptr,type);`
Rückgabewert: | nächstes Argument
Beschreibung: | Ermöglicht Umgang mit variabler Anzahl von Argumenten bei Funktionsaufrufen. Übergibt das nächste optionale Argument der Funktion, auf die `argptr` zeigt. Dazu muß der Datentyp `type` des Argumentes angegeben werden.
Beispiel: | siehe va_start

## va_end

Bibliothek: | `#include <stdarg.h>`
Prototyp: | `void va_end(va_list argptr);`
Rückgabewert: | keiner
Beschreibung: | Ermöglicht Umgang mit variabler Anzahl von Argumenten bei Funktionsaufrufen. Wird aufgerufen, wenn alle optionalen Argumente einer Funktion gelesen wurden. `argptr` wird auf 0 gesetzt.
Beispiel: | siehe va_start

## va_start

Bibliothek: | `#include <stdarg.h>`
Prototyp: | `void va_start(va_list argptr,lastfix);`
Rückgabewert: | keiner
Beschreibung: | Ermöglicht Umgang mit variabler Anzahl von Argumenten bei Funktionsaufrufen. Initialisiert den Zeiger `argptr` (zeigt auf erstes optionales Argument).`lastfix` muß der letzte obligate Parameter sein.
Beispiel: |
    float durchschnitt(int anz, ...)
       {
       int count, gesamt = 0;
       va_list arg_ptr;

       va_start(arg_ptr, anz);
       for (count = 0; count < anz; count++)
         gesamt += va_arg( arg_ptr, int );
       va_end(arg_ptr);
       return ((float)gesamt/anz);
       }

    int main(void)
      {
      float x;
      x = durchschnitt(10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
      printf("DerDurchschnittswert beträgt %f.\n", x);
      return(0);
      }

## vfprintf

Bibliothek: | `#include <stdio.h>`
Bibliothek: | `#include <stdarg.h>`
Prototyp: | `int vfprintf(FILE *fp,const char *formatstring, va_list argptr);`
Rückgabewert: | Anzahl der ausgegebenen Zeichen
Beschreibung: | Entspricht der Funktion `fprintf` mit dem Unterschied, daß statt der Argumentenliste ein Zeiger auf diese erwartet wird.
Beispiel: | siehe fprintf

## vprintf

Bibliothek: | `#include <stdio.h>`
Bibliothek: | `#include <stdarg.h>`
Prototyp: | `int vprintf(const char *formatstring, va_list argptr);`
Rückgabewert: | Anzahl der ausgegebenen Zeichen
Beschreibung: | Entspricht der Funktion `printf` mit dem Unterschied, daß statt der Argumentenliste ein Zeiger auf diese erwartet wird
Beispiel: | siehe printf

## vsprintf

Bibliothek: | `#include <stdio.h>`
Bibliothek: | `#include <stdarg.h>`
Prototyp: | `int vsprintf(char *buf, const char *formatstring, va_list argptr);`
Rückgabewert: | Anzahl der ausgegebenen Zeichen
Beschreibung: | Entspricht der Funktion `sprintf` mit dem Unterschied, daß statt der Argumentenliste ein Zeiger auf diese erwartet wird
Beispiel: | siehe printf

Zum Inhaltsverzeichnis | Zum nächsten Abschnitt

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