Bibliotheken

Dieser Teil von ManderC ist noch in Bearbeitung. Vorerst muss man sich mit einer rudimentären Auflistung begnügen. Man beachte dass diese Einträge während der frühen Programmier-Jahre des Autors entstanden und (momentan noch) teilweise unkorrekt sein können.

assert.h

Mittels assert kann eine Bedingung überprüft werden. Ist die Bedingung FALSE, so wird das Programm mit entsprechender Fehlermeldung abgebrochen.

void assert(int Bedingung) Sicherstellung der Bedingung

ctype.h

Diese Funktionen geben true oder false zurück, je nachdem, ob das übergebene Ascii-Zeichen den Kriterien entspricht.

`int isalnum(int Asc)`	Alphanumerische Zeichen
`int isalpha(int Asc)`	Buchstaben a bis z und A bis Z
`int iscntrl(int Asc)`	Steuerzeichen 0x00 bis 0x1F und 0x7F
`int isdigit(int Asc)`	Ziffern 0 bis 9
`int isgraph(int Asc)`	Druckbare Zeichen (keine Leerzeichen)
`int islower(int Asc)`	Kleinbuchstaben a bis z
`int isprint(int Asc)`	Druckbare Zeichen 0x20 bis 0x7E
`int ispunct(int Asc)`	Interpunktionszeichen
`int isspace(int Asc)`	weisse Leerzeichen (0x09 bis 0x0D und 0x20)
`int isupper(int Asc)`	Grossbuchstaben A bis Z
`int isxdigit(int Asc)`	hexadezimale Ziffern 0 bis 9 und A bis F

Diese beiden Funktionen wandeln Buchstaben in ihr klein- bzw. gross-Pendant um.

`int tolower(int Asc)`	Umwandlung in Kleinbuchstaben
`int toupper(int Asc)`	Umwandlung in Grossbuchstaben

locale.h

Diese beiden Funktionen dienen der Anpassung der länderspezifischen Einstellungen. Sie werden hier nicht weiter erläutert.

struct lconv* localeconv(void)

char *setlocale(int, const char*)

math.h

`double sin(double ang)`	Sinus
`double cos(double ang)`	Cosinus
`double tan(double ang)`	Tangens
`double asin(double val)`	Arcussinus
`double acos(double val)`	Arcuscosinus
`double atan(double val)`	Arcustangens
`double atan2(double x, double y)`	Arcustangens von x/y
`double sinh(double ang)`	Sinus Hyperbolicus
`double cosh(double ang)`	Cosinus Hyperbolicus
`double tanh(double ang)`	Tangens Hyperbolicus

Winkel werden stets in rad angegeben.

`double sqrt(double val)`	Quadratwurzel
`double pow(double bas, double exp)`	Power, Potenzierung: bas^exp
`double exp(double val)`	Exponent
`double ldexp(double val, int exp)`	val*2^exp
`double fabs(double val)`	Betrag, Absolutwert
`double ceil(double val)`	Aufrunden
`double floor(double val)`	Abrunden
`double fmod(double x, double y)`	x modulo y
`double log(double val)`	log Basis e
`double log10(double val)`	log Basis 10
`double frexp(double val, int* exp)`	Mantisse und Exponent
`double modf(double v1, double* v2)`	Ganzzahl und Dezimalbruch

Die Funktionen frexp und modf geben je zwei Werte zurück, wobei der zweite mittels Übergabe durch Pointer zurückgegeben wird.

setjmp.h

Diese beiden Funktionen dienen der Zwischenspeicherung vom Programmstatus. Sie werden hier nicht weiter erläutert.

void longjmp(jmp_buf, int)

int setjmp(jmp_buf)

signal.h

Diese beiden Funktionen dienen der manuellen Interruptkontrolle. Sie werden hier nicht weiter erläutert.

int raise(int)

void signal(int, void*(int))(int)

stdarg.h

Diese drei Makros dienen der variablen Übergabe von Argumenten. Sie werden hier nicht weiter erläutert.

va_arg(va_list)

va_end(va_list)

va_start(va_list)

stdio.h

Diese Bibliothek enthält alle Funktionen, die für die Ein- und Ausgabe zuständig sind. Fast alle bedienen sich dabei sogenannter Streams. Streams sind allgemein definiert als ein aktiviertes lineares Interface zwischen Programm und Hardware. Häufigste Anwendung ist dabei eine Datei, weshalb der Typ auch FILE* heisst. Die folgenden Funktionen sind unter anderem speziell für Dateien gemacht:

`void clearer(FILE* stream)`	Flags zurücksetzen
`int fclose(FILE* stream)`	Stream schliessen
`int feof(FILE* stream)`	gibt 0 zurück, wenn Dateiende noch nicht erreicht
`int ferror(FILE* stream)`	gibt 0 zurück, wenn alles in Ordnung ist
`int fflush(FILE* stream)`	Puffer leeren
`int fgetc(FILE* stream)`	ein Zeichen lesen
`int fgetpos(FILE* stream, fpos_t* pos)`	pos enthält die Position im Stream
`char* fgets(char* str, int i, FILE* stream)`	Liest String bis \n aber maximal i-1 Zeichen
`FILE* fopen(const char* Name, const char* modus)`	Öffnet einen Stream im angegebenen Modus
`int fprintf(FILE* stream, const char* format, ...)`	In einen Stream werden formtierte Daten ausgegeben
`int fputc(int zeichen, FILE* stream)`	Ein Zeichen schreiben
`int fputs(const char* str, FILE* stream)`	String schreiben
`size_t fread(void* Puffer, size_t Grösse, size_t Anz, FILE* stream)`	liest maximal 64 KB in den Puffer
`FILE* freopen(const char* Name, const char* modus, FILE* stream)`	ordnet Stream einer anderen Datei zu
`int fscanf(FILE* stream, const char* format, ...)`	liest formatierte Daten ein
`int fsetpos(FILE* stream, const fpos_t* pos)`	Setzt den Dateipointer auf eine absolute Position
`long ftell(FILE* stream)`	gibt den Positionspointer zurück
`size_t fwrite(const void* Puffer, size_t Grösse, size_t Anz, FILE* stream)`	schreibt maximal 64 KB in den Puffer
`int remove(const char* Datei)`	Datei wird gelöscht
`int rename(const char* Datei1, const char* Datei2)`	Umbenennen der Datei
`void rewind(FILE* stream)`	Zurücksetzen der Flags und zurück zum Dateianfang
`FILE* tmpfile(void)`	Temporäre Datei erstellen
`char* tmpnam(char* str)`	Benannte temporäre Datei erstellen

Die folgenden Funktionen sind speziell für die Eingabe über Tastatur (stdin) und die Ausgabe über Bildschirm (stdout) gedacht:

`int getc(FILE* stream)`	liest ein Zeichen
`int getchar(void)`	liest ein Zeichen aus stdin
`char* gets(char* str)`	liest eine Zeichenkette aus stdin
`void perror(const char* str)`	gibt eine Fehlermeldung mit str aus
`int printf(const char* str, ...)`	gibt den formatierten String aus
`int putc(int asc, FILE* stream)`	gibt ein Zeichen aus
`int putchar(int asc)`	gibt ein Zeichen auf stdout aus
`int puts(const char* str)`	gibt den String auf stdout aus
`int scanf(const char* str, ...)`	Liest einen formatierten String von stdin

Die folgenden Funktionen sind zuständig für allgemeine Puffer- und Stream-Anweisungen, sie werden normalerweise erst bei manueller Dateiansteuerung benutzt.

`void setbuf(FILE* stream, char* Puffer)`	Weist dem stream einen Puffer zu
`int setvbuf(FILE* stream, char* modus, int, size_t Grösse)`	Weist dem stream die Art des Puffers zu
`int sprintf(char* Puffer, const char* str, ...)`	Formatierte Ausgabe des Strings in den Puffer
`int sscanf(const char* Puffer, const char* str, ...)`	formatiertes Herauslesen aus dem Puffer
`int ungetc(int asc, FILE* stream)`	Fehlerhalber gelesenes Zeichen wird wieder zurückgeschrieben zu
`int vfprintf(FILE* stream, const char* format, va_list list)`	formatierte Ausgabe in einen Stream
`int vprintf(const char* str, va_list list)`	formatierte Ausgabe an strout
`int vsprintf(char* Puffer, const char* str, va_list list)`	formatierte Ausgabe mittels String-Zwischenspeicherung

stdlib.h

Stdlib enthält verschiedenste Funktionen. Zum einen gehören dazu folgende Programm-Steuer-Funktionen:

`void abort(void)`	Abbruch
`int atexit(void* (fn)(void))`	Beenden-Funktion wird festgesetzt
`void exit(int status)`	Programmende
`char* getenv(const char* name)`	Umbegungsvariable wird gesucht
`int system(const char* Befehl)`	Programm wird für Befehl unterbrochen

Einfache mathematische Funktionen:

`int abs(int val)`	Betrag
`long labs(long val)`	Betrag von longint
`div_tdiv(int x, int y)`	Berechnung von x div y und x mod y
`ldiv_t ldiv(long x, long y)`	Gleich wie div, aber mit long
`int rand(void)`	Zufallszahl
`void srand(unsigned int start)`	Festlegen der Generator-Basis

Einige Umwandlungsfunktionen:

`double atof(const char* str)`	Umwandlung von String in float
`int atoi(const char* str)`	Umwandlung von String in integer
`long atol(const char* str)`	Umwandlung von String in long
`double strtod(const char* str, char** ende)`	Umwandlung von string in double
`long strtol(const char* str, char** ende, int basis)`	Umwandlung von string in long
`unsigned long strtoul(const char* str, char** ende, int basis)`	Umwandlung von string in unsigned long

Funktionen für Multibyte:

`int mblen(const char* multibyte, size_t Anz)`	Ermitteln der Länge
`size_t mbstowcs(wchar_t, const char, size_t)`	Umwandlung von String in wchar_t
`size_t mbtowc(wchar_t, const char, size_t)`	Umwandlung eines Zeichens in wchar_t
`size_t wcstombs(char, const wchar_t, size_t)`	Umwandlung in Multibyte
`size_t wctomb(char, wchar_t)`	Umwandlung in Multibyte

Speicher-Funktionen:

`void* calloc(size_t Anz, size_t Groesse)`	Reservation und 0-Initialisierung von Anz*Grösse Bytes, maximal 64 KB
`void free(void* block)`	Freigabe des Speicherblocks
`void* malloc(size_t Groesse)`	Reservation von Groesse Bytes
`void* realloc(void* block, size_t Groesse)`	Grössenänderung des Speicherblockes

Und zwei gängige Such- und Sortier-Algorithmen:

`void* bsearch(const void, const void size_t, size_t, int(const void, const void*))`	Binäre Suche
`void qsort(void, size_t, size_t, int(const void, const void))`	Quicksort

string.h

String-Funktionen:

`char* strcat(char, const char)`	Strings aneinanderhängen
`char* strchr(const char*, int)`	String durchsuchen nach Zeichen
`int strcmp(const char, const char)`	Strings vergleichen
`char* strcpy(char, const char)`	String kopieren
`size_t strcspn(const char, const char)`	Vergleich und Länge des fehlenden Stücks
`char* strerror(int)`	Fehlermeldung
`size_t strlen(const char*)`	Länge des Strings
`char* strncat(char, const char, size_t)`	Zeichen anhängen
`int strncmp(const char, const char, size_t)`	Vergleich der Anzahl Zeichen
`char* strncpy(char, const char, size_t)`	Anzahl Zeichen kopieren
`char* strpbrk(const char, const char)`	Durchsuchen nach Zeichen eines zweiten Strings
`char* strrchr(const char*, int)`	Suche nach Zeichen
`size_t strspn(const char, const char)`	Länge des identischen Teilstücks
`char* strstr(const char, const char)`	Teilstring suchen
`char* strtok(char*, const char)`	Tokens finden

Speicher-Funktionen:

`void* memchr(const void*, int, size_t)`	Suche nach Zeichen
`int memcmp(const void, const void, size_t)`	Lexikalischer Vergleich
`void* memcpy(void, const void, size_t)`	Kopieren
`void* memmove(void, const void, size_t)`	Verschieben
`void* memset(void*, int, size_t)`	Speicher füllen
`int strcoll(const char, const char)`	landesspezifischer Vergleich
`size_t strxfrm(char, const char, size_t)`	landesspezifische Umwandlung von Zeichen

time.h, wctype.h, wchar.h

noch nicht vorhanden

Vordefinierte Konstanten

Viele Funktionen der Standardbibliotheken bieten eine Fülle an Optionen an. Dafür müssen jedoch jeweils die korrekten Werte übergeben werden. Hier sind die wichtigsten aufgelistet:

fopen:

a              Daten anhängen. Falls Datei nicht existiert, wird neue Datei erstellt.
a+             Gleich wie a, aber mit Lesezugriff
r              Nur Lesen. Fehler, wenn Datei nicht geöffnet werden kann.
r+             Gleich wie r, nur mit Schreibzugriff
w              Nur Schreiben. Wenn Datei bereits existent, wird sie überschrieben!!
w+             Gleich wie w, nur mit Lesezugriff.

fseek:

SEEK_CUR       aktuelle Position
SEEK_END       Dateiende
SEEK_SET       Dateianfang

printf/scanf:

%d             Dezimal-Integer
%o             Oktal-Integer
%x             Hexadezimal-Integer
%i             allgemeiner Integer
%u             vorzeichenloser Integer
%e             Fliesskommazahl in Exponentialschreibweise
%f             Fliesskommazahl
%g             Fliesskommazahl in kürzester Schreibweise
%c             ein Zeichen
%s             String

rand:

RAND_MAX            0x7FFF     grösstmögliche Zufallszahl

setbuf:

BUFSIZ                 512     Normale Puffergrösse

setvbuf:

_IOFBF         volle Pufferung bis Zwischenspeicher voll
_IOLBF         zwilenweise Pufferung
_IONBF         keine Pufferung