#include <stdio.h>

int putc(int c, FILE *fp);

Der Makro schreibt das Zeichen c auf die aktuelle Position der Datei

putc(c,fp); /* schreibt das Zeichen c an die aktuelle Position

der Datei, die mit fp verbunden ist */

#include <stdio.h>

int putchar(int c);

Der Makro schreibt das Zeichen c auf die Standardausgabe. (putc(c,stdout) ist wirkungsgleich zu putchar(c)).

putchar(c); /* gibt das Zeichen c über stdout aus */

#include <stdio.h>

int puts(const char *string);

schreibt den String string auf die Standardausgabe stdout, abschließend wird ein Newline-Zeichen '\n' ausgegeben.

puts("Ausgabe");

/* gibt 'Ausgabe' mit abschließendem Zeilenumbruch auf stdout aus */

#include <stdlib.h>

void qsort(void *array,size__t n,

size__t size, int (*compare)());

sortiert das Feld array aufsteigend nach 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

qsort(zahlenfeld,zahlenanzahl,sizeof(zahl),vergleich);

/* sortiert ein Feld von Zahlen zahlenfeld mit zahlenanzahl

Elementen der Größe sizeof(zahl) mit Hilfe der Vergleichsfunktion

vergleich nach dem Quick-Sort-Algorithmus */

#include <signal.h>

int raise(int sig);

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 behandelt.

#include <stdlib.h>

int rand(void);

liefert eine Pseudo-Zufallszahl, die zwischen 0 und RAND__MAX liegt. RAND__MAX ist in stdlib.h definiert und ist mindestens 32767. Die Initialisierung erfolgt mit srand.

realloc

#include <stdlib.h>

void *realloc(void *ptr, size__t n);

Rückgabewert: typenloser Zeiger auf zugewiesenen Speicher; im Fehlerfall: NULL-Zeiger

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.

realloc(zeiger,anzahl*sizeof(typ));

/* ändert die Größe des durch zeiger bezeichneten Speicherbereiches

auf einen Wert, so dass er anzahl Variablen vom Typ typ aufnehmen

kann */

#include <stdio.h>

int remove(const char *filename);

die unter filename angegebene Datei lässt sich nicht mehr unter ihrem Namen ansprechen, verfügt sie über keine weiteren 'links' (Dateinamen), so wird sie gelöscht. Verzeichnisse oder read-only-Dateien können nicht gelöscht werden. Bei Fehlern erhält errno den Wert EACCES bzw. ENOENT.

remove("bsp.txt");

/* löscht die Datei 'bsp.txt' */

#include <stdio.h>

int rename(const char *altname,

const char *neuname);

benennt die Datei altname in neuname um. altname muss bereits existieren. Eintrag von neuname in ein anderes Verzeichnis ist möglich, nicht jedoch Eintrag in ein anderes Laufwerk.

rename("\\praxis\\bsp.txt","\\praxis\\thema1\\bsp1.txt");

/* benennt die Datei bsp.txt im Verzeichnis \praxis in

bsp1.txt im Verzeichnis \praxis\thema1 um */

#include <stdio.h>

void rewind(FILE *fp);

Rückgabewert: keiner

setzt den Seek-Zeiger der Datei auf den Dateianfang zurück, löscht das Dateiende-Flag und das Fehler-Flag

rewind(fp);

/* der Seek-Zeiger der mit fp verbundenen Datei wird auf den

Dateianfang zurückgesetzt, das Dateiende- und das Fehler-Flag

werden gelöscht */

#include <stdio.h>

int scanf(const char *formatstring,...,

[arg1,...,argn]);

liest Zeichen in formatierter Form von der Standardeingabe stdin ein und legt sie konvertiert auf den Argumenten arg1 bis argn ab. Die Interpretation der eingelesenen Zeichen erfolgt durch den Format-String formatstring.

Für jedes Formatelement des Strings muss ein Argument angegeben sein (überzählige werden ignoriert).

Formatelemente haben folgende Form:

(siehe printf)

Eingabefelder werden durch Zwischenraumzeichen 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 muss 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.

#include <stdio.h>

void setbuf(FILE *fp, char *buffer);

richtet für die mit dem Dateizeiger verbundene Datei den Dateipuffer buffer ein. Iieser muss die Länge BUFSIZ haben. BUFSIZ ist in stdio.h definiert. Falls buffer ein NULL-Zeiger ist, ist die Ein-/Ausgabe ungepuffert. setbuf() muss sofort nach dem Öffnen der Datei aufgerufen werden.

char puffer[BUFSIZ];

setbuf(fp,puffer);

/* setzt einen Ein-/Ausgabepuffer der Größe BUFSIZ

für die mit fp verbundene Datei */

#include <setjmp.h>

int setjmp(jmp__buf env);

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.

setjmp(env); /* speichert den aktuellen Zustand und die Stack-

Umgebung in der Variablen env */

#include <stdio.h>

int setvbuf (FILE *fp,char *buffer,

int mode,size__t size);

Rückgabewert:

Fehlerfall: Wert ungleich 0; andernfalls : 0

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:

Ein-/Ausgabe werden vollständig gepuffert

Ausgaben werden zeilenweise gepuffert, Eingaben werden vollständig gepuffert

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

setvbuf(fp,buffer,__IONBF,sizeof(buffer);

/* setzt für die mit fp verbundene Datei eine ungepufferte

Ein-/Ausgabe (buffer und sizeof(buffer) werden ignoriert) */

#include <signal.h>

void (*signal (int sig,

void (*func)(int)))(int);

Rückgabewert:

Fehlerfall : SIG__ERR; erster Aufruf : SIG__DFL; andernfalls: Wert von func aus dem vorhergehenden Aufruf

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 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 Standardroutine eingesetzt, dann die eigentliche

Reaktion auf das momentane Signal ausgeführt)

Folgende Signaltypen sind nach ANSI-Standard in signal.h definiert:

abnormale Programmbeendigung (z.B. durch abort; Beenden des Programms)

SIGFPE

Divisions-,Coprozessor- oder Emulationsfehler

durch Drücken von '^C'

durch ungültigen Speicherzugriff

Software-Beendigung des Programms (unter UNIX Standardsignal des Kill-Kommandos)

Bei Fehlern erhält errno den Wert EINVAL

#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);

while(1) 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=getch() | 0x20 != 'j' && c!='n');

if(c == 'j') exit(0);

signal(SIGINT,sig_handler);

#include <math.h>

double sin(double x);

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 (große Ungenauigkeit bei großen Argumenten).

printf("sin(0.0) = %4.1f\n", sin(0.0));

/* Ausgabe: sin(0.0) = 0.0 */

#include <math.h>

double sinh(double x);

liefert den Sinus Hyperbolicus von x. Bei einem Überlauf erhält errno den Wert ERANGE.

printf("sinh(0.0) = 8.4f\n",sinh(0.0));

/* Ausgabe: sinh(0.0) = 0.0000 */

#include <stdio.h>

int sprintf(char *string,const char

*formatstring,... [arg1,...,argn]);

kopiert formatstring mit den Werten aus der Argumentliste formatiert in den String string (Stringende-Zeichen wird angehängt)

sprintf(text,"%15s",name);

/* kopiert den 15 Zeichen langen String name in den

Speicher, der durch text adressiert wird */

#include <math.h>

double sqrt(double x);

liefert die Quadratwurzel von x. Falls x negativ ist, erhält errno den Wert ERANGE

printf("sqrt(9) = %3.1f\n",sqrt(9));

/* Ausgabe: sqrt(9) = 3.0 */

#include <stdlib.h>

void srand(unsigned n);

initialisiert den Zufallszahlengenerator mit n; anschließend erzeugt rand eine neue Folge von Zufallszahlen

srand(5); /* initialisiert den Generator mit 5 */

#include <stdio.h>

int sscanf(char *string,const char *formatstring,

... [arg1,...,argn]);

liest und konvertiert Daten aus dem String string und schreibt sie in die durch die Argumentliste bezeichneten Variablen

sscanf(adresse,"%[^,],%[^,],%d",ort,straße, &hausnr);

/* liest aus dem String adresse 1.Teilstring (bis zu einem Komma)

in die Variable ort, 2. Teilstring (bis zu einem Komma)

in straße und den Rest (eine Zahl) in hausnr */

#include <string.h>

char *strcat(char *s1,const char *s2);

kettet den String s2 an das Ende des Strings s1 (Stringende-Zeichen von s1 wird überschrieben). s1 muss s2 aufnehmen können.

strcat(s1,s2); /* hängt s2 an s1 an */

#include <string.h>

char *strchr(const char *s,int c);

sucht nach dem 1. Auftreten des Zeichens c im String s

strchr(text,zeichen);

/* sucht im String text nach dem 1. Auftreten des Zeichens zeichen */

#include <string.h>

int strcmp(const char *s1,const char *s2);

= 0 falls s1 = s2

und

> 0 falls s1 > s2

vergleicht die Strings s1 und s2 lexikographisch

strcmp("HALLO","hallo");

/* vergleicht die beiden Strings 'HALLO' und

'hallo' miteinander ('hallo' ist größer als 'HALLO',

da im ASCII die Kleinbuchstaben höherwertig sind) */

#include <string.h>

char *strcpy(char *s1,const char *s2);

Beschreibung:

kopiert s2 in den von s1 adressierten Speicher

strcpy(s1,s2);

/* kopiert s2 in den Speicher von s1 (s1 geht verloren) */

#include <string.h>

int strcspn(const char *s1,const char *s2);

liefert Länge des Teilstrings von s1, der keines der Zeichen von s2 enthält

strnspn("Das Ergebnis ist 5","0123456789");

/* gibt die Länge des Strings bis zum 1. Auftreten einer Ziffer an */

#include <string.h>

char *strerror(int errnr);

liefert einen Zeiger auf die zur Zahl errnr gehörende Systemfehlermeldung zurück. Die Zahl errnr ist meist der in errno gespeicherte Wert.

fehlertext = strerror(errno);

/* weist der Variablen fehlertext die Fehlermeldung zu,

die durch errno charakterisiert wird */

#include <string.h>

size__t strlen(const char *s);

Rückgabewert: Länge des Strings

liefert die Länge des Strings s (ohne Stringende-Zeichen). size__t ist in string.h als unsigned int definiert

strlen("Beispiel");

/* bestimmt die Länge des Strings 'Beispiel' */

#include <string.h>

char *strncat(char *s1,const char *s2,size__t n);

strncat(s1,s2,5);

/* hängt die ersten 5 Zeichen von String s2 an s1 an */

#include <string.h>

= 0 falls s1 = s2

und

> 0 falls s1 > s2

vergleicht die ersten n Zeichen von s1 und s2. Der Vergleich wird beim ersten Stringende-Zeichen abgebrochen

strncmp(s1,s2,10);

/* vergleicht die ersten 10 Zeichen von s1 und s2 */

#include <string.h>

char *strncpy(char *s1,const char *s2,size__t n);

strncpy(s1,"Testphase",4);

/*kopiert 'Test' in den durch s1 bezeichneten char-Vektor */

#include <string.h>

char *strpbrk(const char *s1,const char *s2);

durchsucht s1 nach einem der in s2 enthaltenen Zeichen

zeiger= strpbrk("Blumenweg 3","1234567890");

/* weist dem Pointer zeiger die Adresse der 1.Ziffer des Strings zu */

#include <string.h>

char *strrchr(const char *s,int c);

sucht nach letztem Auftreten des Zeichens c im String s

zeiger= strrchr("Teststring",'s');

/* weist zeiger die Adresse des 2. s in 'Teststring' zu */

#include <string.h>

int strspn(const char *s1,const char *s2);

ermittelt Länge des Teilstrings von s1, der nur aus in s2 enthaltenen Zeichen besteht

laenge= strspn("450 Artikel","1234567890");

/* weist laenge die Länge des nur aus Ziffern bestehenden

Teilstrings zu */

#include <string.h>

char *strstr(const char *s1,const char *s2);

sucht im String s1 nach s2

puts(strstr("Heute ist es sehr heiß","sehr"));

/* gibt mit Hilfe der Funktion puts 'sehr heiß' aus */

#include <stdlib.h>

double strtod(const char *s,char **endptr);

Überlauf: HUGE__VAL mit Vorzeichen; Unterlauf: 0

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.

printf("Zahl: %f\n",strtod("200,5 Kilo",&rest));

/* Ausgabe: Zahl: 200.5; rest zeigt auf 'Kilo' */

#include <string.h>

char *strtok(char *s1,const char *s2);

zerlegt String s1 in 'Token', die durch Zeichen aus s2 voneinander getrennt sind. Beim 1. Aufruf muss 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

zeiger = strtok("Hallo, wie geht es"," ");

zeiger1 = strtok(0," ");

/* zeiger zeigt auf 'Hallo,' und zeiger1 auf 'wie' */

#include <stdlib.h>

long strtol(const char *s,char **endptr,int base);

führende Zeichenfolge in s wird in eine long-Zahl konvertiert; die Zeichenfolge wird als Zahl zur Basis base interpretiert. Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung abgebrochen. endptr zeigt auf das erste nicht interpretierbare Zeichen bei einem Überlauf erhält errno den Wert ERANGE.

printf("Zahl:%ld\n",strtol(10 Leute",&rest,10));

/* Ausgabe: Zahl: 10; rest zeigt auf die restlichen

String-Zeichen 'Leute' */

#include <stdlib.h>

unsigned long strtoul(const char *s,char **endptr,int base);

wandelt führende Zeichenfolge von s in eine unsigned long-Zahl um (Zahl zur Basis base) Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung abgebrochen endptr zeigt auf das erste nicht mehr interpretierbare Zeichen bei einem Überlauf erhält errno den Wert ERANGE.

printf("Zahl : %ld\n",strtoul(2000 Einwohner,&rest,10);

/* Ausgabe: Zahl : 2000; rest zeigt auf den Reststring 'Einwohner' */

#include <stdlib.h>

int system(const char *s);

NULL-Zeiger übergeben:

- Kommandointerpreter nicht verfügbar: 0

- sonst:

Wert ungleich 0

Argument kein NULL-Zeiger:

- compilerabhängig, in der Regel 0 bei korrekter Ausführung

Wert ungleich 0 bei einem Fehler

schickt den String s an den Kommandointerpreter des Betriebssystems. Die Bearbeitung erfolgt wie bei am Prompt eingegebenen Befehlen.

system("CLS");

/* löscht über den Kommandointerpreter des Betriebssystems

den Bildschirm */

#include <math.h>

double tan(double x);

liefert den Tangens von x. Die Angabe erfolgt im Bogenmaß.

printf("tan(1.0) = %7.4f\n",tan(1.0));

/* Ausgabe: tan(1.0) = 1.5574 */

#include <math.h>

double tanh(double x);

liefert den Tangens Hyperbolicus von x

printf("tanh(2.0) = %7.4f\n",tanh(2.0));

/* Ausgabe: tanh(2.0) = 0.9640 */

#include <time.h>

time__t time(time__t *ptr);

liefert Anzahl der Sekunden seit 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.

time(&zeit);

/* speichert die Anzahl der Sekunden seit 1.1.1970 0 Uhr in zeit */

#include <stdio.h>

FILE *tmpfile(void)

öffnet eine temporäre Datei im Binärmodus zum Schreiben und Lesen. Diese Datei wird automatisch bei Programmende oder beim Schließen gelöscht.

fp = tmpfile();

/* dem File-Pointer fp wird eine temporäre Datei zugeordnet */

#include <stdio.h>

char *tmpnam(char *s);

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 muss 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.

tmpnam(name);

/* speichert in name einen neuen Dateinamen */

#include <ctype.h>

int tolower(int c);

konvertiert den in c gespeicherten Großbuchstaben in einen Kleinbuchstaben. Jedes andere Zeichen bleibt unverändert (nur ASCII-Zeichen 0 bis 127 betrachtet).

klein = tolower(gross);

/* weist klein den umgewandelten Großbuchstaben zu */

#include <ctype.h>

int toupper(int c);

konvertiert den in c gespeicherten Kleinbuchstaben in einen Großbuchstaben. Andere Zeichen bleiben unverändert (nur ASCII-Zeichen 0 - 127 betrachtet).

gross = toupper(klein);

/* weist gross den umgewandelten Kleinbuchstaben klein zu */

#include <stdio.h>

int ungetc(int c, FILE *fp);

schreibt das Zeichen c wieder in den Dateipuffer zurück. Sollte ein EOF-Flag gesetzt sein, wird es gelöscht. Die nachfolgende Leseoperation beginnt mit dem Zeichen c. Die Datei muss zum Lesen geöffnet sein.

ungetc(c,fp);

/* schreibt das Zeichen c in den Dateipuffer der mit fp

verbundenen Datei */

#include <stdarg.h>

type va__arg(va__list argptr,type);

ermöglicht Umgang mit variabler Anzahl von Argumenten bei Funktionsaufrufen. Übergibt das nächste optionale Argument der Funktion, auf die argptr zeigt. Dazu muss der Datentyp type des Argumentes angegeben werden.

#include <stdarg.h>

void va__end(va__list argptr);

sollte aufgerufen werden, wenn alle optionalen Argumente einer Funktion gelesen wurden. argptr wird auf 0 gesetzt.

#include <stdarg.h>

void va__start(va__list argptr,lastfix);

ermöglicht Umgang mit variabler Anzahl von Argumenten bei Funktionsaufrufen initialisiert den Zeiger argptr (zeigt auf erstes optionales Argument). lastfix muss der letzte obligatorische Parameter sein

#include <stdio.h>

#include <stdarg.h>

entspricht der Funktion fprintf mit dem Unterschied, dass statt der Argumentenliste ein Zeiger auf diese erwartet wird

siehe fprintf

#include <stdio.h>

#include <stdarg.h>

int vprintf(const char *formatstring, va__list argptr);

entspricht der Funktion printf mit dem Unterschied, dass statt der Argumentenliste ein Zeiger auf diese erwartet wird

siehe printf

#include <stdio.h>

#include <stdarg.h>

entspricht der Funktion sprintf mit dem Unterschied, dass statt der Argumentenliste ein Zeiger auf diese erwartet wird

siehe sprintf