#include <stdlib.h>

void abort(void);

Gibt die Meldung Abnormal program termination an Fehlerausgabe stderr und bricht den laufenden Prozess ab (Normaler Programmabbruch siehe exit).

if (fp= fopen("\\autoexec.bat","r") == NULL)

printf("Datei autoexec.bat nicht im Rootverzeichnis gefunden\n");

abort();

#include <stdlib.h>

int abs(int x);

Berechnet den Absolutwert des int-Wertes x (siehe auch labs und fabs).

printf("abs(-8) = %d\n",abs(-8));

/* Ausgabe: abs(-8) = 8 */

#include <math.h>

double acos(double x);

Berechnet den Arcus Cosinus des Argumentes x (-1 <= x <= +1)

printf("acos(-1.0) = %6.4f\n",acos(-1.0));

printf("acos( 0.0) = %6.4f\n",acos( 0.0));

printf("acos( 1.0) = %6.4f\n",acos( 1.0));

/* Ausgabe: acos(-1.0) = 3.1416

acos( 0.0) = 1.5708

acos( 1.0) = 0.0000 */

#include <time.h>

char *asctime(struct tm

*systime);

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)

struct tm *systime;

time_t sec;

time(&sec);

systime = localtime (&sec);

printf("Datum und Uhrzeit: %s\n",asctime(systime));

/* Ausgabe: Datum und Uhrzeit: Mon Oct 28 9:00:48 1996 */

#include <math.h>

double asin(double x);

Berechnet den Arcus Sinus des Argumentes x (-1 <= x <= +1).

printf("asin(-1.0) = %7.4f",asin(-1.0));

/* Ausgabe: asin(-1.0) = -1.5708 */

#include <assert.h>

void assert(int expression);

Der Makro überprüft den Ausdruck expression. Ist das Ergebnis 0 (Fehler) so wird die Meldung:

Assertion failed: expression, file: name, line: number

ausgegeben. Danach erfolgt Programmabbruch. Makro um logische Fehler im Programm zu finden.

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 ... */

#include <math.h>;

double atan(double x);

Berechnet den Arcus Tangens des Argumentes x; Umkehrfunktion des Tangens.

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

/* Ausgabe: atan(-1.0) = -0.7854 */

#include <math.h>

double atan2(double y, double x);

Berechnet den Arcus Tangens 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 */

#include <stdlib.h>

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

Returnwert:

Im Fehlerfall ein Wert ungleich 0, sonst 0.

Der Funktion atexit wird ein Zeiger func auf eine Funktion vom Typ void übergeben, die am Ende des Programms aufgerufen werden soll. Durch folgende Aufrufe von atexit werden weitere Zeiger auf eine Funktion registriert, die nach dem 'last in, first out' - Prinzip verwaltet werden.

main()

void func1(void), func2(void);

atexit(func1);

atexit(func2);

printf("\nEnde des Programms.\n");

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

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

/* Ausgabe: Ende des Programms.

Das ist Funktion func2().

Das ist Funktion func1(). */

#include <stdlib.h>

double atof(const char *s);

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 abgebrochen. Zwischenraumzeichen werden ignoriert.

char *string = "-12.356e+2";

double z;

z= atof(string);

printf("z = %.2f\n",z);

/* Ausgabe: z = -1235.60 */

#include <stdlib.h>

int atoi(const *s);

Returnwert:

Gibt den int-Wert der in der Zeichenkette gespeicherten Zahl zurück. Falls Auswertung nicht möglich, wird 0 zurückgegeben.

Wandelt eine als Zeichenkette gespeicherte dezimale Ganzzahl in einen int-Wert um. Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung abgebrochen. Ein Dezimalpunkt oder Exponent wird nicht als Teil der Zahl angesehen.

char *s= "+123 Biere";

printf("atoi(s) = %d\n",atoi(s));

/* Ausgabe: atoi(s) = 123 */

#include <stdlib.h>

long atol(const char *s);

Returnwert:

Gibt den long-Wert der in der Zeichenkette gespeicherten Zahl zurück. Falls Auswertung nicht möglich, wird 0 zurückgegeben.

Wandelt eine als Zeichenkette gespeicherte dezimale Ganzzahl in einen long-Wert um. Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung abgebrochen. Ein Dezimalpunkt oder Exponent wird nicht als Teil der Zahl angesehen.

char *s= "-12345678.-Gehalt";

printf("atol(s) = %ld\n",atol(s));

/* Ausgabe: atol(s) = -12345678 */

#include <stdlib.h>

void *bsearch (const void *key, const void *array, size_t n,

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

Returnwert:

Gibt die Adresse des ersten Vektorelementes zurück, das mit dem gesuchten Wert übereinstimmt. Gibt es ein solches Vektorelement nicht, so wird der NULL-Zeiger zurückgegeben.

Verwendet das binäre Suchverfahren, 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);

static char *farben[]={"rot","grün","blau","gelb","weiß"};

static char key[]= "pink";

if (bsearch(key,farben,5,sizeof(char*),scmp) == NULL)

printf("Farbe %s nicht gefunden\n",key);

...

int scmp(char **s1, char **s2) { return strcmp(*s1, *s2); }

#include <stdlib.h>

void *calloc(size__t n, size__t size);

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. Wenn nicht genügend Speicherplatz vorhanden ist, wird ein NULL-Zeiger zurückgeliefert.

if (calloc(5,sizeof(int)) == 0)

printf("Nicht genügend Speicher\n");

/* Speicherreservierung für 5 Elemente vom Typ int;

#include <math.h>

double ceil(double x);

Rückgabewert:

x aufgerundet

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 */

#include <stdio.h>

void clearerr(FILE *fp);

löscht das Fehler-Flag und das Dateiende-Flag der mit fp verbundenen Datei.

clearerr(fp); /* löscht Fehler- und Dateiende-Flag der fp-Datei. */

#include <time.h>

clock__t clock (void);

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.

z = clock(); /* weist z die Anzahl von "Ticks" zu,

die seit Programmstart vergangen sind */

#include <math.h>

double cos(double x);

liefert den Cosinus von x (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.

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

/* Ausgabe: cos(0.0) = 1.0 */

#include <math.h>

double cosh(double x);

Rückgabewert :

cosh(x)

printf("cosh(-2.0) = %6.4f\n", cosh(-2.0));

/* Ausgabe: cosh(-2.0) = 3.7622 */

#include <time.h>

Prototyp:

char *ctime(const time__t *zeit);

konvertiert Datum und Uhrzeit in einen String. zeit ist die Anzahl der Sekunden seit dem 1.1.1970 00:00:00 Uhr (GMT). Der erzeugte String hat folgendes Format:

Wochentag Monat Monatstag Zeit (hh:mm:ss) Jahr (vierstellig)

time__t ist in time.h als long definiert.

time__t sec;

time(&sec);

printf("Datum und Zeit: %s\n", ctime(&sec));

/* Ausgabe: Datum und Zeit: Mon Oct 28 09:15:48 1996 */

#include <time.h>

double difftime(time__t time2,time__t time1);

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.

printf("Arbeitszeit: %.0f Sekunden\n", difftime(stoptime,starttime));

/* Ausgabe der Differenz zwischen starttime und stoptime */

#include <stdlib.h>

div__t div(int x,int y);

Rückgabewert:

Struktur vom Typ div__t

dividiert x durch y und legt Ergebnis und Rest in einer Struktur vom Typ div__t ab. div__t ist in stdlib.h definiert.

div__t res;

res = div(10,3);

printf("10/3 = %d, Rest %d\n",res.quot,res.rem);

/* Ausgabe: 10/3 = 3 Rest 1 */

#include <stdlib.h>

void exit(int status);

Rückgabewert:

keiner

beendet ein Programm. Dateipuffer werden übertragen und Dateien werden geschlossen. status stellt den Exit-Code dar.

exit(1); /* beendet das Programm und liefert den

Exit-Code 1 zurück */

#include <math.h>

double exp(double x);

e^x

printf("exp(-3.0) = %7.4f\n", exp(-3.0));

/* Ausgabe: exp(-3.0) = 0.0498 */

#include <math.h>

double fabs(double x);

printf("fabs(-3.8) = %3.1f\n", fabs(-3.8));

/* Ausgabe: fabs(-3.8) = 3.8 */

#include <stdio.h>

int fclose(FILE *fp);

schließt die mit fp verbundene Datei überträgt den Inhalt des Dateipuffers. Der Speicherbereich des E/A-Puffers wird wieder freigegeben.

if (fclose(fp) == 0)

printf("Datei wurde geschlossen\n");

#include <stdio.h>

int feof(FILE *fp);

Rückgabewert:

Dateiende-Flag gesetzt: Wert ungleich 0; andernfalls: 0

Der Makro prüft, ob das Dateiende erreicht ist

while (!feof(fp))...

/* führt nachfolgenden Befehl solange aus,

bis das Dateiende erreicht ist */

#include <stdio.h>

int ferror(FILE *fp);

Der Makro überprüft, ob ein Fehler beim Zugriff auf dieDatei auftrat

if (ferror(fp)) printf("Fehler beim Zugriff\n");

#include <stdio.h>

int fflush(FILE *fp);

überträgt den Inhalt des Dateipuffers:

Schreibmodus:

Dateipuffer wird geschrieben

Lesemodus :

Puffer wird geleert

if (fflush(fp) == EOF)

printf("Puffer nicht geschrieben\n");

#include <stdio.h>

int fgetc(FILE *fp);

liest aus der Datei das Zeichen von der aktuellen Position (Position wird 1 erhöht)

c = fgetc(fp); /* weist c das Zeichen der aktuellen Position zu */

#include <stdio.h>

int fgetpos(FILE *fp, fpos__t *ppos);

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.

fgetpos(fp,&pos);

#include <stdio.h>

char *fgets(char *string, int n, FILE *fp);

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 oder bis "\n" .

if (fgets(name,21,fp) != 0) printf("1. Name: %s\n", name);

/* Ausgabe: 1. Name: xxxx */

#include <math.h>

double floor(double x);

ermittelt die größte ganze Zahl, die kleiner oder gleich x ist (Abrundung)

printf("floor(1.9) = %4.1f\n", floor(1.9));

/* Ausgabe: floor(1.9) = 1 */

#include <math.h>

double fmod(double x,double y);

Rückgabewert:

Rest der Division x/y

Modulo-Division der double-Werte x und y

printf("fmod(9.5,4.5) = %3.1f\n", fmod(9.5,4.5));

/* Ausgabe: fmod(9.5,4.5) = 0.5 */

#include <stdio.h>

FILE *fopen(const char *name,

const char *modus);

Rückgabewert:

File-Pointer

ö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. FILE ist in stdio.h definiert. Liste der verschiedenen Modi:

"r"

Lesen

"r+"

Lesen / Schreiben

"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

bei r und r+ muss die Datei existieren

fp = fopen("bsp.txt","r");

/* öffnet die bereits existierende Datei bsp.txt

zum Lesen (fp wird mit der Datei verbunden) */

#include <stdio.h>

int fprintf(FILE *fp,const char

formatstring, ... );

schreibt Formatstring in die mit fp verbundene Datei (Formatierung zulässig)

fprintf(fp,"2 * 2 = %d \n",2*2);

/* Ausgabe von: 2 * 2 = 4 in die Datei,

die mit fp verbunden ist */