Anfang

Die Standard Bibliothek

Die Standard-Bibliothek ist kein Teil der Programmiersprache C selbst, aber jede Umgebung, die Standard C realisiert, stellt die Funktionen und Makros dieser Bibliothek zur Verfügung.

Die Funktionen und Makros der Standard-Bibliothek sind in Standard-Definitionsdateien deklariert:
<assert.h> <float.h> <math.h> <stdarg.h> <stdlib.h>
<ctype.h> <limits.h> <setjmp.h> <stddef.h> <string.h>
<errno.h> <locale.h> <signal.h> <stdio.h> <time.h>
Auf eine Definitionsdatei header wird mit
#include <header>
zugegriffen.

Im Folgenden werden tabellarisch Funktionen, Typen, Konstanten oder Makros aus der Standard-Bibliothek aufgelistet. Diese werden in folgende Bereiche eingeteilt:

 

Ein- und Ausgabe:   <stdio.h>

Bezeichner / Aufruf Argument / Rückgabewert / Erläuterung
n = printf(f, x, ...); Auf stdout (Ausgabe) formatiert schreiben
char *f Formatstring
x Ausdruck, Typ passend zu Formatstring, variable Anzahl von Ausdrücken möglich
int n Anzahl der ausgegebenen Zeichen; EOF bei Fehler
n = sprintf(b, f, x, ...); In einen String formatiert schreiben
char *b Schreibbuffer für den String
char *f Formatstring
x Ausdruck, Typ passend zu Formatstring, variable Anzahl von Ausdrücken möglich
int n Anzahl der ausgegebenen Zeichen (ohne abschließendes 0-Byte); EOF bei Fehler
n = scanf(f, v, ...); Von stdin (Eingabe) formatiert lesen
char *f Formatstring
v Variable, Typ passend zu Formatstring, variable Anzahl möglich
int n Anzahl der eingelesenen Felder; EOF bei Fehler
n = sscanf(b, f, v, ...); Von einem String formatiert lesen
char *b String aus dem eingelesen wird
char *f Formatstring
v Variable, Typ passend zu Formatstring, variable Anzahl möglich
int n Anzahl der eingelesenen Felder; EOF bei einem Leseversuch am Ende des Strings
r = putchar(c); Ein Zeichen auf den Ausgabekanal schreiben
int c auszugebendes Zeichen
int r ausgegebenes Zeichen; EOF bei Fehler
c = getchar(); Ein Zeichen von stdin lesen
int c eingelesenes Zeichen; EOF bei Fehler
r = puts(buf); Eine Zeichenkette auf den Ausgabekanal schreiben
char *buf auszugebende Zeichenkette
int r positiver Wert; EOF bei Fehler
r = gets(buf); Eine Zeichenkette von stdin lesen
char buf[...] Platz für einzulesende Zeichenkette
char *r Zeiger auf buf; Nullpointer bei Fehler
perror(txt); Ausgabe des Fehlers auf den Standardfehlerkanal (stderr)
Zeichenkette txt wird angehängt.
char *txt auszugebende Zeichenkette
top

 

Datei- Ein / Ausgabe:   <stdio.h>

Es werden nur die wichtigsten Definitionen der Datei- Ein / Ausgabe vorgestellt.

Bezeichner / Aufruf Argument / Rückgabewert / Erläuterung
FILE Datentyp für Datei- Ein / Ausgabe
EOF Ganzzahlige Konstante; negativer Wert, der als Funktionsergebnis das Ende der Datei oder Fehler anzeigt.
SEEK_SET
SEEK_CUR
SEEK_END
Ganzzahlige Konstanten für das Setzen der Schreib- / Leseposition in einer Datei.
size_t Datentyp für Größenangaben (in Byte)
stdin
stdout
stderr
Konstanten vom Typ FILE*. Zeiger auf standardmäßig verfügbare und geöffnete Dateien für Ein / Ausgabe bzw. Fehlermeldungen
fp = fopen(f, m); Datei öffnen zum Lesen oder Schreiben
char *f Dateiname; mit oder ohne Pfadangabe
char *m Dateimodus;
FILE *fp Filepointer identifiziert Datei in folgenden Aktionen
r = fclose(fp); Datei schließen
FILE *fp Filepointer gibt an, welche Datei
int r 0 falls ok, EOF bei Fehler
r = remove(fp); Datei löschen
FILE *fp Filepointer gibt an, welche Datei
int r 0 falls ok, ungleich 0 bei Fehler
r = rename(old, new); Datei umbenennen
char *old alter Dateiname
char *new neuer Dateiname
int r 0 falls ok, ungleich 0 bei Fehler
r = fflush(fp); I/O-Kanal leeren; Bei einem Ausgabestrom werden gepufferte, noch nicht geschriebene Daten geschrieben; bei einem Eingabekanal ist der Effekt undefiniert.
FILE *fp Pointer gibt an, welcher Datenstrom;
fflush(NULL) bezieht sich auf alle offenen Dateien.
int r Die Funktion liefert EOF bei Fehlern sonst Null
n = fprintf(fp, f, x, ...); In Ausgabekanal formatiert ausgeben, wie printf aber in Datei fp
FILE *fp Dateizeiger gibt an, in welche Datei
char *f Formatstring
x Ausdruck, Typ passend zu Formatstring, variable Anzahl von Ausdrücken möglich
int n Anzahl der ausgegebenen Zeichen; EOF bei Fehler
n = fscanf(fp, f, v, ...); Aus Datei fp formatiert lesen
FILE *fp Dateizeiger gibt an, aus welcher Datei
char *f Formatstring
v Variable, Typ passend zu Formatstring, variable Anzahl möglich
int n Anzahl der eingelesenen Felder; EOF bei Fehler
r = fputc(c, fp); Ein Zeichen in den Ausgabekanal schreiben
int c auszugebendes Zeichen
FILE *fp Dateizeiger gibt an, in welche Datei
int r ausgegebenes Zeichen; EOF bei Fehler
r = putc(c, fp); Analog zu fputc(), kann aber ein Makro sein
c = fgetc(fp);Ein Zeichen vom Eingabekanal lesen
int c eingelesenes Zeichen; EOF bei Fehler
FILE *fp Dateizeiger gibt an, aus welcher Datei
c = getc(fp);Analog fgetc(), kann aber ein Makro sein
r = ungetc(c, fp); Stellt gelesenes Zeichen (umgewandelt in unsigned char) wieder in den Eingabepuffer zurück.
int c zurückzustellendes Zeichen; EOF darf nicht zurückgestellt werden.
FILE *fp Dateizeiger gibt an, in welchen Datenstrom
int r zurückgestelltes Zeichen oder EOF bei Fehler
r = fputs(buf, fp); Eine Zeichenkette in den Ausgabekanal schreiben
char *buf auszugebende Zeichenkette
FILE *fp Filepointer gibt an, in welche Datei
int r positiver Wert; EOF bei Fehler
r = fgets(buf, n, fp); Es werden höchstens die nächsten n - 1 Zeichen vom Eingabekanal in buf eingelesen. Der Vorgang wird auch bei Eingabe eines Zeilentrenners unterbrochen, wobei der Zeilentrenner mitabgespeichert wird. An die Zeichenkette wird '\0' angehängt.
char buf[...] Platz für einzulesende Zeichenkette
FILE *fp Filepointer gibt an, aus welcher Datei
int n Zahl der einzulesenden Zeichen minus eins
char *r Zeiger auf buf; Nullpointer bei Dateiende oder Fehler
n = fread(buf, size, anz, fp); Byteorientiertes Lesen vom Eingabekanal
void *buf Zeiger auf Platz für einzulesende Bytes
size_t size Größe eines Datensatzes
size_t anz Anzahl der Datensätze
FILE *fp Filepointer gibt an, aus welcher Datei
size_t n Anzahl der gelesenen Datensätze
n = fwrite(buf, size, anz, fp); Byteorientiertes Schreiben auf den Ausgabekanal
void *buf Zeiger auf Platz für auszugebende Bytes
size_t size Größe eines Datensatzes
size_t anz Anzahl der Datensätze
FILE *fp Filepointer gibt an, in welche Datei
size_t n Anzahl der ausgegebenen Datensätze, bei Fehler ist das kleiner als n
r = fseek(fp, offset, origin); Schreib- / Lese- Position in der Datei setzen
FILE *fp Filepointer gibt an, für welche Datei
long offset Anzahl der Bytes, um die versetzt wird
int origin von wo ab versetzt wird (SEEK_SET, SEEK_CUR, SEEK_END)
int r 0 falls ok, !=0 bei Fehler
int fgetpos(FILE *, fpos_t);Merken der aktuellen Dateiposition
int fsetpos(FILE *, fpos_t *);Zurückspringen an eine gemerkte Dateiposition
long int ftell(FILE *); Ermitteln einer aktuellen Dateiposition
void rewind(FILE *); Dateizeiger auf Dateianfang setzen
void clearerr(FILE *); Fehlervariable löschen
int feof(FILE *); Abfrage, ob Textdateiende erreicht wurde
int ferror(FILE *); Ermitteln, ob ein Dateifehler auftrat

Die Ein- und Ausgabefunktionen, Typen und Makros, die in <stdio.h> vereinbart sind, machen fast ein Drittel der Bibliothek aus.

top

 

Mathematische Funktionen:   <math.h>

Bezeichner / Aufruf Argument / Rückgabewert / Erläuterung
y = sin(x);
y = cos(x);
y = tan(x);
Trigonometrische Funktionen
double x Argument im Bogenmaß
double y Ergebniswert
y = sinh(x);
y = cosh(x);
y = tanh(x);
Hyperbel - Funktionen
double x Argument
double y Ergebniswert
y = asin(x);
y = acos(x);
Zyklometrische Funktionen
double x Argument mit -1 <= x <= 1
double y Ergebniswert im Bogenmaß mit Pi/2 <= y <= Pi/2
z = atan(x);
z = atan2(y, x);
Zyklometrische Funktionen
double x Argument
double y Argument
double z Für atan(x) Ergebniswert im Bogenmaß mit -Pi/2 <= z <= Pi/2
Für atan2(y, x) Ergebniswert im Bogenmaß mit -Pi <= z <= Pi
y = sqrt(x);
Quadratwurzel
double x Radikand mit x >= 0
double y Ergebnis
z = pow(x, y);
Potenzfunktion
double x Argument 1
double y Argument 2;
wenn x < 0 muss y ganzzahlig sein
wenn x = 0 muss y positiv sein
double z Ergebnis für xy
y = exp(x);
Exponentialfunktion zur Basis e
double x Argument
double y Ergebnis für ex
y = log(x);
y = log10(x);
Logarithmus zur Basis e und Logarithmus zur Basis 10
double x Argument, es muss gelten: x > 0
double y Ergebnis für ln(x) bzw. log10(x)
y = fabs(x); Absolutwert bestimmen
double x Argument
double y Absolutwert von x
y = ceil(x); "Ceiling", Decke
double x Argument
double y Kleinste ganze Zahl größer gleich x   [ceil(4.5) ergibt 5.0, ceil(-4.5) ergibt -4.0]
y = floor(x); "Floor", Boden
double x Argument
double y Größte ganze Zahl kleiner gleich x   [floor(4.5) ergibt 4.0, floor(-4.5) ergibt -5.0]
z = fmod(x, y); Modulo für Fließkommazahlen
double x Argument 1
double y Argument 2
double y Gleitpunktrest von x/y, mit dem gleichen Vorzeichen wie x. Falls y=0, hängt das Ergebnis von der Implementierung ab.
mantis = frexp(x, *exp); Aufteilung einer Fließkomrnazahl nach den Regeln des IEEE-Formats:
zerlegt x in eine normalisierte Mantisse (double mantis) im Bereich [1/2,1),
und eine Potenz (int *exp) von 2. Ist x = 0, sind beide Teile des Resultats Null.
y = ldexp(x, n); Multiplikation mit einem Vielfachen von 2
double x Argument 1
int n Argument 2
double y Ergebnis: x·2n
rest = modf(x, ip); Aufteilung einer Fließkommazahl x in ganzahligen Teil (double *ip) und einen Rest (double rest), die beide das gleiche Vorzeichen wie x besitzen.
top

 

Zufallszahlen:   <stdlib.h>

Bezeichner / Aufruf Argument / Rückgabewert / Erläuterung
RAND_MAX Konstante: Maximaler Ergebniswert der Funktion rand()
n = rand(); Gleichverteilte Zufallszahlen
int n Zufallszahl 0 <= n <= RAND_MAX
srand(n); Keim ("seed") für Zufallszahlengenerator setzen.
unsigned n Keim, initialisiert Zufallsfolge
top

 

Zeichenbehandlung:   <ctype.h>

Bezeichner / Aufruf Argument / Rückgabewert / Erläuterung
int isalnum(int);Test auf Ziffern und Buchstaben;
übergeben wird ein Zeichen in einer Variablen oder als Konstante
int isalpha(int);Test auf Buchstaben
int iscntrl(int);Test auf Steuerzeichen
int isdigit(int);Test auf Ziffern
int isgraph(int);Test auf Grafikzeichen
int islower(int);Test, ob es Kleinbuchstabe ist
int isprint(int);Test, ob es druckbares Zeichen ist
int ispunct(int);Test, ob es ein Interpunktionszeichen ist
int isspace(int);Test, ob es ein Leerzeichen ist
int isupper(int);Test, ob es ein Großbuchstabe ist
int isxdigit(int);Test, ob es ein Hexadezirnalziffernzeichen ist
int tolower(int);Umwandlung zu Großbuchstaben
int toupper(int);Umwandlung zu Kleinbuchstaben

Das Argument ist jeweils der Ganzzahlwert des Zeichens. Der Rückgabewert bei den Testfunktionen ist Null falls das Zeichen nicht der Abfrage enspricht, sonst ungleich Null. Bei den Umwandlungsfunktionen wird ggf. das umgewandelte Zeichen zurückgeliefert.

top

 

Zeichenketten:   <string.h>

Bezeichner / Aufruf Argument / Rückgabewert / Erläuterung
NULL Konstante für Nullzeiger
n = strlen(s); Zeichenkettenlänge feststellen
char *s Zeichenkette
size_t n Ergebnis
sz = strcpy(sz, sq); Stringkopie eines gesamten Strings; der Rückgabewert ist ein Zeiger auf die Ziel-Zeichenkette
char *sz Ziel-Zeichenkette (hinreichend groß)
char *sq Quell-Zeichenkette (mit '\0' terminiert)
sz = strncpy(sz, sq, n); Stringkopie eines Teilstrings; Ergebnis: Zeiger auf sz.
char *sz Ziel-Zeichenkette (hinreichend groß)
char *sq Quell-Zeichenkette (mit '\0' terminiert)
size_t n Anzahl zu kopierender Zeichen
sz = strcat(sz, sq); Stringverbindung eines Gesamtstrings; Ergebnis: Zeiger auf sz.
char *sz Ziel-Zeichenkette (hinreichend groß)
char *sq Quell-Zeichenkette (mit '\0' terminiert)
sz = strncat(sz, sq, n); Stringverbindung eines Teilstrings
char *sz Ziel-Zeichenkette (hinreichend groß)
char *sq Quell-Zeichenkette (mit '\0' terminiert)
size_t n Anzahl zu kopierender Zeichen
i = strcmp(s1, s2); Lexikographischer Vergleich zweier Strings
char *s1 Zeichenkette 1 (mit '\0' terminiert)
char *s2 Zeichenkette 2 (mit '\0' terminiert)
int i
Ergebnis:
s1 < s2    =>   i < 0
s1 == s2   =>   i == 0
s1 > s2    =>   i > 0
p = strchr(s, c); Sucht Zeichen c in String s
char *s Zeichenkette (mit '\0' terminiert)
int c zu suchendes Zeichen
char *p Liefert Zeiger auf das erste c in s oder NULL, falls nicht vorhanden
p = strstr(s1, s2); Sucht Zeichenkette s2 in Zeichenkette s1
char *s1 Zeichenkette 1 (mit '\0' terminiert)
char *s2 Zeichenkette 2 (mit '\0' terminiert)
char *p Liefert Zeiger auf erstes Auftreten von s2 in s1 oder NULL, falls nicht vorhanden
top

 

Konvertierung:   <stdlib.h>

Bezeichner / Aufruf Argument / Rückgabewert / Erläuterung
n = atoi(s); Zeichenkette s in Ganzzahl n wandeln
d = atof(s); Zeichenkette s in Fließkommazahl f wandeln
l = atol(s); Zeichenkette s in long Zahl l wandeln
dbl = strtod(s, *endp); Zeichenkettenausschnitt in double Zahl wandeln
char *s Zeichenkette
char **endp Zeiger auf nicht umgewandelten Rest der Zeichenkette
double dbl gewandelte Fließkommazahl
top

 

Speicherverwaltung:   <stdlib.h>

Bezeichner / Aufruf Argument / Rückgabewert / Erläuterung
p = malloc(n); Speicherbereich von n Bytes reservieren
int n Größe des Speicherblockes in Byte
void *p Liefert Zeiger auf den reservierten Speicherblock (NULL, falls nicht genügend Platz vorhanden)
free(p); Speicher freigeben
void *p Zeiger auf einen früher mit malloc reservierten Speicherblock
top

 

Beenden:   <stdlib.h>

Bezeichner / Aufruf Argument / Rückgabewert / Erläuterung
void abort(void); Programmabbruch mit Meldung "Abnormal program termination"
int atexit(void(*)(void)); Installation einer Funktion, die bei Aufruf von exit() gestartet wird
void exit(int); Schließt alle Dateien und beendet das laufende Programm
r = system(s); Übergibt die Zeichenkette s dem Kommandozeileninterpreter des Systems.
char *s Kommando-Zeichenkette
int r Resultat: 0 bedeutet OK
top


home