C-Programmierung: Standard Header

Inhaltsverzeichnis

Einführung in die Standard Header

Die 16 ANSI C (C89) und 3 weiteren ISO C (C94/95) Header sind ein Teil der C++98 Standard Library, die ISO C99 Library ist Teil des C++ Standards ab TR1 (Technical Report 1 von 2005).

Weitere Hintergrundinformationen zur Standardbibliothek finden Sie in der Wikipedia.

ANSI C (C89)/ISO C (C90) Header

assert.h

Testmöglichkeiten und Fehlersuche.

ctype.h

Die Datei ctype.h enthält diverse Funktionen mit denen sich einzelne Zeichen überprüfen lassen oder umgewandelt werden können.

Übersicht

Der Header ctype.h enthält diverse Funktionen, mit denen sich einzelne Zeichen überprüfen lassen oder umgewandelt werden können. Die Funktionen liefern einen von 0 verschiedenen Wert, wenn c die Bedingung erfüllt, andernfalls liefern sie 0:

• int isalnum(int c) testet auf alphanumerisches Zeichen (a-z, A-Z, 0-9)
• int isalpha(int c) testet auf Buchstabe (a-z, A-Z)
• int iscntrl(int c) testet auf Steuerzeichen (\f, \n, \t ...)
• int isdigit(int c) testet auf Dezimalziffer (0-9)
• int isgraph(int c) testet auf druckbare Zeichen ohne Leerzeichen
• int islower(int c) testet auf Kleinbuchstaben (a-z)
• int isprint(int c) testet auf druckbare Zeichen mit Leerzeichen
• int ispunct(int c) testet auf druckbare Interpunktionszeichen
• int isspace(int c) testet auf Zwischenraumzeichen (engl. whitespace) (' ', '\f', '\n', '\r', '\t', '\v')
• int isupper(int c) testet auf Grossbuchstaben (A-Z)
• int isxdigit(int c) testet auf hexadezimale Ziffern (0-9, a-f, A-F)

Zusätzlich sind noch zwei Funktionen für die Umwandlung in Groß- bzw. Kleinbuchstaben definiert:

• int tolower(int c) wandelt Gross- in Kleinbuchstaben um
• int toupper(int c) wandelt Klein- in Grossbuchstaben um

Häufig gemachte Fehler

Wie Sie vielleicht sehen, erwarten die Funktionen aus <ctype.h> als Parameter einen int, obwohl es eigentlich ein char sein sollte. Immerhin arbeiten die Funktionen ja mit Zeichen.

Die Ursache hierfür liegt im C-Standard selbst. Laut C-Standard muss c entweder »als unsigned char repräsentierbar oder der Wert des Makros EOF sein«. Ansonsten ist das Verhalten undefiniert. EOF ist im Standard als negativer int-Wert definiert, unsigned char kann aber niemals negative Werte annehmen. Um dem Standard zu genügen, muss also ein ausreichender Parametertyp deklariert werden, der sowohl den unsigned char-Wertebereich wie auch negative int-Werte abbilden kann. Dies kann der Basisdatentyp int.

Das alleine ist noch nicht schlimm. Aber: in C gibt es drei verschiedene Arten von char-Datentypen: char, signed char und unsigned char. In einer Umgebung mit Zweierkomplementdarstellung, in der ein char 8 Bit groß ist (ja, es gibt auch größere), geht der implementierungsabhängige Wertebereich von signed char meistens von -128 bis +127, der von unsigned char von 0 bis meistens 255. Wenn man jetzt noch annimmt, dass der Zeichensatz ISO-8859-1 (latin1) oder Unicode/UTF-8 ist, darf man diesen Funktionen keine Strings übergeben, die möglicherweise Umlaute enthalten. Ein typisches Beispiel, bei dem das dennoch geschieht, ist:

int all_spaces(const char *s)
{
  while (*s != '\0') {
    if (isspace(*s))       /* FEHLER */
      return 0;
    s++;
  }
  return 1;
}

Der Aufruf von all_spaces("Hallöle") führt dann zu undefiniertem Verhalten. Um das zu vermeiden, muss man das Argument der Funktion isspace in einen unsigned char umwandeln. Das geht zum Beispiel so:

    if (isspace((unsigned char) *s))

errno.h

Die Headerdatei enthält Funktionen zum Umgang mit Fehlermeldungen und die globale Variable errno, welche die Fehlernummer des zuletzt aufgetretenen Fehlers implementiert.

float.h

Die Datei float.h enthält Definitionen zur Bearbeitung von Fließkommazahlen in C.

Der Standard definiert eine Gleitkommazahl nach dem folgenden Modell (in Klammern die symbolischen Konstanten für den Typ float):

$x=sb^{e}\sum _{k=1}^{p}f_{k}\cdot b^{-k},e_{min}\leq e\leq e_{max}$

• s = Vorzeichen
• b = Basis ( FLT_RADIX )
• e = Exponent (Wert zwischen FLT_MIN und FLT_MAX )
• p = Genauigkeit ( FLT_MANT_DIG )
• f_k = nichtnegative Ganzzahl kleiner b

Der Standard weist darauf hin, dass hierbei nur um ein Beschreibung der Implementierung von Fließkommazahlen handelt und sich von der tatsächlichen Implementierung unterscheidet.

Mit float.h stehen folgende Gleitkommatypen zur Verfügung:

• float
• double
• long double

Für alle Gleitkommatypen definierte symbolische Konstanten:

• FLT_RADIX (2) Basis
• FLT_ROUND Erhält die Art der Rundung einer Implementierung:
  • -1 unbestimmt
  • 0 in Richtung 0
  • 1 zum nächsten Wert
  • 2 in Richtung plus unendlich
  • 3 in Richtung minus unendlich

Die symbolische Konstante FLT_ROUND kann auch andere Werte annehmen, wenn die Implementierung ein anderes Rundungsverfahren benutzt.

Für den Typ Float sind definiert:

• FLT_MANT_DIG Anzahl der Ziffern in der Mantisse
• FLT_DIG (6) Genauigkeit in Dezimalziffern
• FLT_EPSILON (1E-5) kleinste Zahl x für die gilt 1.0 + x ≠ 1.0
• FLT_MAX (1E+37) größte Zahl, die der Typ float darstellen kann
• FLT_MIN (1E-37) kleinste Zahl größer als 0, die der Typ float noch darstellen kann
• FLT_MAX_EXP Minimale Größe des Exponent
• FLT_MIN_EXP Maximale Größe des Exponent

Für den Typ Double sind definiert:

• DBL_MANT_DIG Anzahl der Ziffern in der Matisse
• DBL_DIG (10) Genauigkeit in Dezimalziffern
• DBL_EPSILON (1E-9) kleinste Zahl x für die gilt 1.0 + x ≠ 1.0
• DBL_MAX (1E+37) größte Zahl, die der Typ double darstellen kann
• DBL_MIN (1E-37) kleinste Zahl größer als 0, die der Typ double noch darstellen kann
• DBL_MAX_EXP Minimale Größe des Exponent
• DBL_MIN_EXP Maximale Größe des Exponent

Für den Typ Long Double sind definiert:

• LDBL_MANT_DIG Anzahl der Ziffern in der Matisse
• LDBL_DIG (10) Genauigkeit in Dezimalziffern
• LDBL_EPSILON (1E-9) kleinste Zahl x für die gilt 1.0 + x ≠ 1.0
• LDBL_MAX (1E+37) größte Zahl, die der Typ long double darstellen kann
• LDBL_MIN (1E-37) kleinste Zahl größer als 0, die der Typ long double noch darstellen kann
• LDBL_MAX_EXP Minimale Größe des Exponent
• LDBL_MIN_EXP Maximale Größe des Exponent

limits.h

Enthält die implementierungsspezifischen Minimal- und Maximalwerte für die einzelnen Datentypen.

Die Headerdatei erhält die Werte, die ein Typ auf einer bestimmten Implementierung annehmen kann. In Klammern befinden sich die jeweiligen Mindestgrößen. Für den Typ char sind zwei unterschiedliche Größen angegeben, da es von der Implementierung abhängig ist, ob dieser vorzeichenbehaftet oder vorzeichenlos ist. Der Wertebereich ist immer asymmetrisch (z. B. -128, +127).

• CHAR_BIT Anzahl der Bits in einem char (8 Bit)
• SCHAR_MIN minimaler Wert, den der Typ signed char aufnehmen kann (-128)
• SCHAR_MAX maximaler Wert, den der Typ signed char aufnehmen kann (+127)
• UCHAR_MAX maximaler Wert, den der Typ unsigned char aufnehmen kann(+255)
• CHAR_MIN minimaler Wert, den die Variable char aufnehmen kann (0 oder SCHAR_MIN)
• CHAR_MAX maximaler Wert, den die Typ char aufnehmen kann (SCHAR_MAX oder UCHAR_MAX)
• SHRT_MIN minimaler Wert, den der Typ short int annehmen kann (-32.768)
• SHRT_MAX maximaler Wert, den der Typ short int annehmen kann (+32.767)
• USHRT_MAX maximaler Wert, den der Typ unsigned short int annehmen kann (+65.535)
• INT_MIN minimaler Wert, den der Typ int annehmen kann (-32.768)
• INT_MAX maximaler Wert, den der Typ int annehmen kann (+32.767)
• UINT_MAX maximaler Wert, den der Typ unsigned int aufnehmen kann(+65.535)
• LONG_MIN minimaler Wert, den der Typ long int annehmen kann (-2.147.483.648)
• LONG_MAX maximaler Wert, den der Typ long int annehmen kann (+2.147.483.647)
• ULONG_MAX maximaler Wert, den der Typ unsigned long int annehmen kann (+4.294.967.295)
• LLONG_MIN minimaler Wert, den der Typ long long int annehmen kann (–9.223.372.036.854.775.808)
• LLONG_MAX maximaler Wert, den der Typ long long int annehmen kann (+9.223.372.036.854.775.807)
• ULLONG_MAX maximaler Wert, den der Typ unsigned long long int annehmen kann (+18.446.744.073.709.551.615)

locale.h

Länderspezifische Eigenheiten wie Formatierungen und Geldbeträge.

math.h

Die Datei math.h enthält diverse höhere mathematische Funktionen, wie z.B. die Wurzeln, Potenzen, Logarithmen und anderes. Sie wird für Berechnungen gebraucht, welche nicht, oder nur umständlich, mit den Operatoren +, -, *, /, % ausgerechnet werden können.

Trigonometrische Funktionen:

• double cos(double x) Kosinus von x
• double sin(double x) Sinus von x
• double tan(double x) Tangens von x
• double acos(double x) arccos(x)
• double asin(double x) arcsin(x)
• double atan(double x) arctan(x)
• double cosh(double x) Cosinus Hyperbolicus von x
• double sinh(double x) Sinus Hyperbolicus von x
• double tanh(double x) Tangens Hyperbolicus von x

Logarithmusfunktionen:

• double exp(double x) Exponentialfunktion (e hoch x)
• double log(double x) natürlicher Logarithmus (Basis e)
• double log10(double x) dekadischer Logarithmus (Basis 10)

Potenzfunktionen:

• double sqrt(double x) Quadratwurzel von x
• double pow(double x, double y) Berechnet $x^{y}$

setjmp.h

Ermöglicht Funktionssprünge.

signal.h

Ermöglicht das Reagieren auf unvorhersehbare Ereignisse.

Die Datei signal.h enthält Makros für bestimmte Ereignisse, wie Laufzeitfehler und Unterbrechungsanforderungen und Funktionen, um auf diese Ereignisse zu reagieren.

stdarg.h

Die Datei stdarg.h enthält Makros und einen Datentyp zum Arbeiten mit variablen Parameterlisten.

• va_list

Datentyp für einen Zeiger auf eine variable Parameterliste

• void va_start(va_list par_liste, letzter_par);

initialisiert die Parameterliste anhand des letzten Parameters letzter_par und assoziiert sie mit par_liste

• type va_arg(va_list par_liste, type);

liefert den nächsten Parameter der mit par_liste assoziierten Parameterliste mit dem spezifiziertem Typ type zurück

• void va_end(va_list par_liste);

gibt den von der variablen Parameterlist par_liste belegten Speicherplatz frei

stddef.h

Allgemein benötigte Definitionen.

size_t

Implementierungsabhängiger, vorzeichenloser, ganzzahliger Variablentyp.

NULL

Das Makro repräsentiert einen Speicherbereich, der nicht gültig ist. Eine mögliche Implementierung des Makros lautet:

#ifndef NULL
 #define NULL ((void *) 0)
#endif 

stdio.h

Die Datei stdio.h enthält Funktionen zum Arbeiten mit Dateien und zur formatierten und unformatierten Eingabe und Ausgabe von Zeichenketten.

Die Datei stdio.h enthält diverse Standard-Input-Output-Funktionen (daher der Name).

FILE

Vordefinierter Standardtyp zur Verwendung in vielen Funktionen zur Ein- und Ausgabe bei Streams bzw. Dateien. Meistens erfolgt die Instanziierung einer Variable für diesen Typ als Zeiger.

NULL

Das Macro für einen Pointer auf einen nicht existierenden Speicherbereich wie es auch in stddef.h definiert ist.

BUFSIZ

dieses Macro definiert die implementierungsspezifische Maximalgröße, die mit setbuf gewählt werden kann als Integerwert.

FOPEN_MAX

Enthält als Integer die Anzahl der möglichen gleichzeitig geöffneten Filepointer, welche diese Implementierung erlaubt.

FILENAME_MAX

Enthält als Integerwert die Maximallänge von Dateinamen mit dem die Implementierung sicher umgehen kann.

stdin

Ist ein immer vorhandener geöffneter Filepointer auf den Standardeingabe-Stream.

stdout

Ist ein immer vorhandener, geöffneter Filepointer auf den Standardausgabe-Stream.

stderr

Ist ein immer vorhandener geöffneter Filepointer auf den Fehlerausgabe-Stream. Lassen Sie sich bitte nicht dadurch verwirren, dass meistens stderr auch auf der Konsole landet: Der Stream ist nicht der gleiche wie stdout.

EOF (End of File)

negativer Wert vom Typ int , der von einigen Funktionen zurückgegeben wird wenn das Ende eines Streams erreicht wurde.

int printf (const char *format, ...)

entspricht fprintf(stdout, const char* format, ...)

Die Umwandlungsangaben (engl. conversion specification) bestehen aus den folgenden Elementen:

• dem  % Zeichen
• Flags
• der Feldbreite (engl. field width), Anzahl der Druckstellen insgesamt
• der Genauigkeit (engl. precision), Zahl der Stellen nach dem Dezimalpunkt (bzw bei %g : Zahl der relevanten Stellen)
• einem Längenhinweis (engl. length modifier), Art der internen Zahlspeicherung (Sonderfall)
• dem Umwandlungszeichen (engl. conversion key)

Die Flags haben die folgende Bedeutung:

• - (Minus): Der Text wird linksbündig ausgerichtet. Wird das Flag nicht gesetzt so wird der Text rechtsbündig ausgerichtet.
• + (Plus): Es wird in jedem Fall ein Vorzeichen ausgegeben und zwar auch dann, wenn die Zahl positiv ist.
• Leerzeichen: Ein Leerzeichen wird ausgegeben. Wenn sowohl + wie auch das Leerzeichen benutzt werden, so wird die Kennzeichnung nicht beachtet und es wird kein Leerzeichen ausgegeben.
• # : Welche Wirkung das Kennzeichen # hat ist abhängig vom verwendeten Format: Wenn ein Wert über %x als Hexadezimal ausgegeben wird, so wird jedem Wert ein 0x vorangestellt (außer der Wert ist 0).
• 0 : Die Auffüllung erfolgt mit führenden Nullen anstelle von Leerzeichen (sofern Minus-Flag nicht gesetzt).

Mögliche Umwandlungszeichen:

• %a , %A : double im Format [-]0xh.hhhhp±d. Wird %a verwendet, so werden die Buchstaben a bis f als abcdef ausgegeben; wenn %A verwendet wird, dann werden die Buchstaben a bis f als ABCDEF ausgegeben (neu im C99 Standard).
• %c : int umgewandelt in char und als Zeichen interpretiert.
• %d , %i : int im Format [-]dddd .
• %e , %E : double in Format [-]d.ddd e±dd bzw. [-]d.ddd E±dd . Die Anzahl der Stellen nach dem Dezimalpunkt entspricht der Genauigkeit. Fehlt die Angabe, so ist sie standardmäßig 6. Ist die Genauigkeit 0 und das # Flag nicht gesetzt, so entfällt der Dezimalpunkt. Der Exponent besteht immer aus mindestens zwei Ziffern. Sind mehr Ziffern zur Darstellung notwendig, so werden nur so viele wie unbedingt notwendig angezeigt. Wenn der darzustellende Wert 0 ist, so ist auch der Exponent 0.
• %f , %F : double im Format [-]ddd.ddd . Die Anzahl der Stellen nach dem Dezimalpunkt entspricht der Genauigkeit. Fehlt die Angabe, so ist sie standardmäßig 6. Ist die Genauigkeit 0 und das # Flag nicht gesetzt, so entfällt der Dezimalpunkt.
• %g , %G : Ein double Argument wird im Stil von e bzw. E ausgegeben, allerdings nur, wenn der Exponent kleiner als -4 ist oder größer / gleich der Genauigkeit. Ansonsten wird das Argument im Stil von %f ausgegeben.
• %n : Das Argument muss ein vorzeichenbehafteter Zeiger sein, bei dem die Anzahl der auf dem Ausgabestrom geschriebenen Zeichen abgelegt wird.
• %o : int als Oktalzahl im Format [-]dddd .
• %p : void* . Der Wert des Zeigers umgewandelt in eine darstellbare Folge von Zeichen, wobei die genaue Darstellung von der Implementierung abhängig ist.
• %s : Das Argumente sollten ein Zeiger auf das erste Element eines Zeichenarray sein. Die nachfolgenden Zeichen werden bis zum \0 ausgegeben.
• %u : unsigned int im Format dddd
• %X , %x : int im Hexadezimalsystem im Format [-]dddd . Wird %x verwendet, so werden die Buchstaben a bis f als abcdef ausgegeben, wenn %X verwendet wird, dann werden die Buchstaben a bis f als ABCDEF ausgegeben. Ist das # Flag gesetzt, dann erscheint die Ausgabe der Hexadezimalzahl mit einem vorangestellten "0x" (außer der Wert ist 0).
•  %% Ein Prozentzeichen wird ausgegeben

Wenn eine Umwandlungsangabe ungültig ist oder ein Argumenttyp nicht dem Umwandlungsschlüssel entspricht, so ist das Verhalten undefiniert.

int fprintf(FILE *fp,const char *format,...)

Die Funktion macht das gleiche wie die Funktion printf , Ausgabe aber nicht nach stdout sondern in einen Stream, der über den Filepointer fp übergeben wird.

int snprintf(char *dest, size_t destsize, const char *format, ...)

Die Funktion snprintf() formatiert die in ... angegebenen Argumente gemäß der printf-Formatierungsvorschrift format und schreibt das Ergebnis in den durch dest angegebenen String. destsize gibt die Maximallänge des Strings dest an. Der String in dest erhält in jedem Fall ein abschließendes Nullzeichen. In keinem Fall wird über dest[destsize - 1] hinausgeschrieben.

Der Rückgabewert ist die Anzahl der Zeichen, die geschrieben worden wäre, wenn der String dest lang genug gewesen wäre.

Um Pufferüberläufe zu vermeiden, sollte diese Funktion gegenüber strcpy, strcat, strncpy und strncat vorgezogen werden, da es bei letzteren Funktionen aufwendig ist, über den noch verfügbaren Platz im String Buch zu führen.

Beispielcode

Das folgende Programm erwartet zwei Argumente auf der Kommandozeile. Diese Argumente werden zu einem Dateinamen, bestehend aus Verzeichnisname und Dateiname, zusammengesetzt und ausgegeben.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
	ssize_t	len = 0;
	char	*fname = NULL;

	if (3 == argc) {
		len = snprintf(NULL, 0, "%s/%s", argv[1], argv[2]);
		fname = malloc( len+1 );
		if (NULL != fname)
		{
			sprintf(fname, "%s/%s", argv[1], argv[2]);
			printf("%s\n", fname); /* oder puts(fname); */
			free(fname);
			return 0; 
		}
	}
	printf("Fehler\n");
	return 1;
}

• mit snprintf() wird zunächst die Länge des benötigten Strings ermittelt
• mit malloc() wird dafür dynamischer Speicher reserviert
• mit sprintf() (nicht snprintf()!) wird dieser Speicher mit dem Ergebnisstring beschrieben, auf stdout ausgegeben und das Programm mit Returncode 0 (äquivalent zu fehlerfrei) beendet, ansonsten mit 1

int sprintf(char *dest,const char *format,...)

Achtung! Da diese Funktion nicht die Länge prüft kann es zum Pufferüberlauf kommen! Deshalb sollte besser snprintf verwendet werden. Wenn dennoch diese Funktion genutzt wird, schreibt sie in den String dest den Formatstring format und gegebenenfalls die weiteren Parameter.

int vprintf(const char *format,va_list list)

Es wird zusätzlich der Header stdarg.h benötigt ! Die Funktion vprintf ist äquivalent zu der Funktion printf außer dass anstelle der variablen Argumentenliste ‘‘...’’ ein va_list-Objekt übergeben wird. Achtung diese Funktion ruft nicht das Makro va_end. Der Inhalt von list ist deshalb nach dem Funktionsaufruf undefiniert ! Nach der Funktion sollte die rufende Instanz deshalb unbedingt das Makro va_end als nächstes aufrufen.

int vfprintf(FILE *stream,const char *format,va_list list)

Es wird zusätzlich der Header stdarg.h benötigt ! Die Funktion vfprintf ist äquivalent zu der Funktion fprintf außer dass anstelle der variablen Argumentenliste ‘‘...’’ ein va_list-Objekt übergeben wird. Achtung diese Funktion ruft nicht das Makro va_end. Der Inhalt von list ist deshalb nach dem Funktionsaufruf undefiniert! Nach der Funktion sollte die rufende Instanz deshalb unbedingt das Makro va_end als nächstes aufrufen.

int vsprintf(char *dest,const char *format,va_list list)

Es wird zusätzlich der Header stdarg.h benötigt ! Die Funktion vsprintf ist äquivalent zu der Funktion sprintf außer dass anstelle der variablen Argumentenliste ‘‘...’’ ein va_list-Objekt übergeben wird. Achtung diese Funktion ruft nicht das Makro va_end. Der Inhalt von list ist deshalb nach dem Funktionsaufruf undefiniert ! Nach der Funktion sollte die rufende Instanz deshalb unbedingt das Makro va_end als nächstes aufrufen.

int vsnprintf(char *dest,size_t destsize,const char *format,va_list list)

Es wird zusätzlich der Header stdarg.h benötigt ! Die Funktion vsnprintf ist äquivalent zu der Funktion snprintf außer dass anstelle der variablen Argumentenliste ‘‘...’’ ein va_list-Objekt übergeben wird. Achtung diese Funktion ruft nicht das Makro va_end. Der Inhalt von list ist deshalb nach dem Funktionsaufruf undefiniert! Nach der Funktion sollte die rufende Instanz deshalb unbedingt das Makro va_end als nächstes aufrufen.

int scanf (const char *formatString, ...)

entspricht fscanf(stdin, const char* formatString, ...)

int fscanf(FILE *fp,const char *format,...)

Die Funktion fscanf(FILE *fp,const char *format); liest eine Eingabe aus dem mit fp übergebenen Stream. Über den Formatstring format wird fscanf mitgeteilt welchen Datentyp die einzelnen Elemente haben, die über Zeiger mit den Werten der Eingabe gefüllt werden. Der Rückgabewert der Funktion ist die Anzahl der erfolgreich eingelesen Datentypen bzw. im Fehlerfall der Wert der Konstante EOF .

int sscanf(const char *src,const *format,...)

Die Funktion ist äquivalent zu fscanf , außer dass die Eingabe aus dem String src gelesen wird.

int vscanf(const char *fromat,va_list list)

Es wird zusätzlich der Header stdarg.h benötigt ! Die Funktion vscanf ist äquivalent zu der Funktion scanf außer dass anstelle der variablen Argumentenliste ‘‘...’’ ein va_list-Objekt übergeben wird. Achtung es wird nicht das Makro va_end aufgerufen. Der Inhalt von list ist nach der Funktion undefiniert!

int vsscanf(const char *src,const char *fromat,va_list list)

Es wird zusätzlich der Header stdarg.h benötigt ! Die Funktion vsscanf ist äquivalent zu der Funktion sscanf außer dass anstelle der variablen Argumentenliste ‘‘...’’ ein va_list-Objekt übergeben wird. Achtung es wird nicht das Makro va_end gerufen der Inhalt von list ist nach der Funktion undefiniert!

int fgetc(FILE *stream)

Die Funktion fgetc(stream); liefert das nächste Zeichen im Stream oder im Fehlerfall EOF .

stdlib.h

Die Datei stdlib.h enthält Funktionen zur Umwandlung von Variablentypen, zur Erzeugung von Zufallszahlen, zur Speicherverwaltung, für den Zugriff auf die Systemumgebung, zum Suchen und Sortieren, sowie für die Integer-Arithmetik (z. B. die Funktion abs für den Absolutbetrag eines Integers).

EXIT_SUCCESS

Dieses Macro enthält den Implementierungsspezifischen Rückgabewert für ein erfolgreich ausgeführtes Programm.

EXIT_FAILURE

Dieses Macro enthält den Implentierungsspezifischen Rückgabewert für ein fehlerhaft beendetes Programm.

NULL

Das Macro repräsentiert einen Zeiger auf einen nicht gültigen Speicherbereich wie in stddef.h erklärt wird.

RAND_MAX

Das Makro ist implementierungsabhängig und liefert den Maximalwert, den die Funktion rand() zurückgeben kann.

double atof (const char *nptr)

Wandelt den Anfangsteil (gültige Zahlendarstellung) einer Zeichenfolge, auf die nptr zeigt, in eine double-Zahl um.

Besser ist die Verwendung der weiter unten beschriebenen Funktion strtod(), da diese auch eine Fehlererkennung erlaubt, wenn in nptr gar kein Zahlenwert steht.

int atoi (const char *nptr)

Wandelt den Anfangsteil (gültige Zahlendarstellung) einer Zeichenfolge, auf die nptr zeigt, in eine int-Zahl um.

Besser ist die Verwendung der weiter unten beschriebenen Funktion strtol() mit anschließender Konvertierung nach int, da dies auch eine Fehlererkennung erlaubt, wenn in nptr gar kein Zahlenwert steht.

long atol (const char *nptr)

Wandelt den Anfangsteil (gültige Zahlendarstellung) einer Zeichenfolge, auf die nptr zeigt, in eine long int-Zahl um.

Besser ist die Verwendung der weiter unten beschriebenen Funktion strtol(), da diese auch eine Fehlererkennung erlaubt, wenn in nptr gar kein Zahlenwert steht.

void exit(int fehlercode)

Beendet das Programm. Als Fehlercode sollte entweder EXIT_SUCCESS oder EXIT_FAILURE verwendet werden.

int rand(void)

Liefert eine Pseudo-Zufallszahl im Bereich von 0 bis RAND_MAX .

long int strtol(const restrict char* nptr, char** restrict endp, int base);

Die Funktion strtol (string to long) wandelt den Anfang einer Zeichenkette nptr in einen Wert des Typs long int um. In endp wird ein Zeiger in *endp auf den nicht umgewandelten Rest abgelegt, sofern das Argument ungleich NULL ist.

Die Basis legt fest, um welches Stellenwertsystem es sich handelt. (2 für das Dualsystem, 8 für das Oktalsystem, 16 für das Hexadezimalsystem und 10 für das Dezimalsystem). Die Basis kann Werte zwischen 2 und 36 sein. Die Buchstaben von a (bzw. A) bis z (bzw. Z) repräsentieren die Werte zwischen 10 und 35. Es sind nur Ziffern und Buchstaben erlaubt, die kleiner als base sind. Ist der Wert für base 0, so wird entweder die Basis 8 ( nptr beginnt mit 0), 10 ( nptr beginnt mit einer von 0 verschiedenen Ziffer) oder 16 ( nptr beginnt mit 0x oder 0X) verwendet. Ist die Basis 16, so zeigt eine vorangestelltes 0x bzw. 0X an, dass es sich um eine Hexadezimalzahl handelt. Wenn nptr mit einem Minuszeichen beginnt, ist der Rückgabewert negativ.

Ist die übergebene Zeichenkette leer oder hat nicht die erwartete Form, wird keine Konvertierung durchgeführt und 0 wird zurückgeliefert. Wenn der korrekte Wert größer als der darstellbare Wert ist, wird LONG_MAX zurückgegeben, ist er kleiner wird LONG_MIN zurückgegeben und das Makro ERANGE wird in errno abgelegt.

long long int strtoll(const restrict char* nptr, char** restrict endp, int base);

(neu in C99 eingeführt)

Die Funktion entspricht strtol mit dem Unterschied, das der Anfang des Strings nptr in einen Wert des Typs long long int umgewandelt wird. Wenn der korrekte Wert größer als der darstellbare Wert ist, wird LLONG_MAX zurückgegeben, ist er kleiner, wird LLONG_MIN zurückgegeben.

unsigned long int strtoul(const restrict char* nptr, char** restrict endp, int base);

Die Funktion entspricht strtol mit dem Unterschied, das der Anfang des Strings nptr in einen Wert des Typs ungsigned long int umgewandelt wird. Wenn der korrekte Wert größer als der darstellbare Wert ist, wird ULONG_MAX zurückgegeben.

unsigned long long int strtoull(const restrict char* nptr, char** restrict endp, int base);

(neu in C99 eingeführt)

Die Funktion entspricht strtol mit dem Unterschied, das der Anfang des Strings nptr in einen Wert des Typs ungsigned long long int umgewandelt wird. Wenn der korrekte Wert größer als der darstellbare Wert ist, wird ULLONG_MAX zurückgegeben.

double strtod(const restrict char* nptr, char** restrict endp);

(neu in C99 eingeführt)

Die Funktion liest einen double-Wert vom Beginn des Strings nptr und gibt den Wert als Ergebnis zurück. Wenn endp nicht NULL ist, wird ein Zeiger auf das erste nicht verarbeitbare Zeichen in *endp gespeichert. Wenn kein verwertbarer Text für das Einlesen eines double-Wertes gefunden wurde (kompletter Fehlschlag), wird die Anfangsadresse nptr in *endp gespeichert. Ist der eingelesene Wert betragsmäßig zu groß für einen double-Wert, gibt die Funktion HUGE_VAL zurück und setzt errno auf ERANGE .

void* malloc(size_t size)

Die Funktion fordert vom System size byte an speicher an und gibt im Erfolgsfall einen Zeiger auf den Beginn des Bereiches zurück, im Fehlerfall NULL.

void free(void *ptr)

Gibt den dynamischen Speicher, der durch ptr repräsentiert wurde wieder frei.

int system(const char* command);

Führt den mit command angegebenen Befehl als Shell-Befehl aus und gibt den Rückgabewert des ausgeführten Prozesses zurück.

void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));

Die qsort Funktion sortiert nmemb Elemente mit jeweils size Bytes Größe im Speicherbereich startend bei base.

compar ist ein Zeiger auf eine Funktion, welche zwei Elemente nach dem gewünschten Sortierkriterium vergleicht, die

== 0 liefert für 2 gleiche Elemente
< 0 liefert falls das erste kleiner als das zweite Argument ist

> 0 liefert falls das erste größer als das zweite Argument ist
In diesem Fall wird aufsteigend sortiert, werden die Bedingungen für beide Argumente vertauscht, wird absteigend sortiert.

string.h

Die Datei string.h enthält Funktionen zum Bearbeiten und Testen von Zeichenketten.

• char* strcpy(char* sDest, const char* sSrc) Kopiert einen String sSrc nach sDest inklusive '\0'
• char* strcat(char* s1, const char* s2) Verbindet zwei Zeichenketten miteinander
• void* strncpy(char* sDest, const char* sSrc, size_t n) Wie strcpy, kopiert jedoch maximal n Zeichen (ggf. ohne '\0').
• size_t strlen(const char* s) Liefert die Länge einer Zeichenkette ohne '\0'
• int strcmp(const char* s1, char* s2) Vergleicht zwei Zeichenketten miteinander. Liefert 0, wenn s1 und s2 gleich sind, <0 wenn s1<s2 und >0 wenn s1>s2
• int strstr(const char* s, const char* sSub) Sucht die Zeichenkette sSub innerhalb der Zeichenkette s. Liefert einen Zeiger auf das erste Auftreten von sSub in s, oder NULL, falls sSub nicht gefunden wurde.
• int strchr(const char* s, int c) Sucht das erste Auftreten des Zeichens c in der Zeichenkette s. Liefert einen Zeiger auf das entsprechende Zeichen in s zurück, oder NULL, falls das Zeichen nicht gefunden wurde.
• void* memcpy(void* sDest, const void* sSrc, size_t n) Kopiert n Bytes von sSrc nach sDest, liefert sDest. Die Speicherblöcke dürfen sich nicht überlappen.
• void* memmove(void* sDest, const void* sSrc, size_t n) Kopiert n Bytes von sSrc nach sDest, liefert sDest. Die Speicherblöcke dürfen sich überlappen.

time.h

time.h enthält Kalender- und Zeitfunktionen.

• time_t Arithmetischer Typ, der die Kalenderzeit repräsentiert.
• time_t time(time_t *tp) Liefert die aktuelle Kalenderzeit. Kann keine Kalenderzeit geliefert werden, so wird der Wert –1 zurückgegeben. Als Übergabeparameter kann ein Zeiger übergeben werden, der nach Aufruf der Funktion ebenfalls die Kalenderzeit liefert. Bei NULL wird dem Zeiger kein Wert zugewiesen.

Neue Header in ISO C (C94/C95)

iso646.h

Folgende Makros sind im Header <iso646.h> definiert, die als alternative Schreibweise für die logischen Operatoren verwendet werden können:

Makro	Operator
and	&&
and_eq	&=
bitand	&
compl	~
not	!
not_eq	!=
or	||
or_eq	|=
xor	^
xor_eq	^=

wchar.h

• int fwprintf(FILE *stream, const wchar_t *format, ...); :

wide character Variante von fprintf

• int fwscanf(FILE *stream, const wchar_t *format, ...); :

wide character Variante von fscanf

• wprintf(const wchar_t *format, ... ); :

wide character Variante von printf

• wscanf(const wchar_t *format, ...); :

wide character :Variante von scanf

• wint_t getwchar(void); :

wide character Variante von getchar

• wint_t putwchar(wchar_t c); :

wide character Variante von putchar

• wchar_t *wcscpy(wchar_t *s1, const wchar_t *s2); :

wide character Variante von strcpy

• wchar_t *wcscat(wchar_t *s1, const wchar_t *s2); :

wide character Variante von strcat

• wchar_t *wcscmp(const wchar_t *s1, const wchar_t *s2); : _

wide character Variante von strcmp

• size_t wcslen(const wchar_t *s); :

wide character Variante von strlen

Neue Header in ISO C (C99)

complex.h

Dieser Header definiert Macros und Funktionen um mit komplexen Zahlen zu rechnen.

Realanteil bestimmen

• double creal(double complex z);
• float crealf(float complex z);
• long double creall(long double complex z);

Imaginäranteil bestimmen

• double cimag(double complex z);
• float cimagf(float complex z);
• long double cimagl(long double complex z);

Betrag einer komplexen Zahl bestimmen

• double cabs(double complex z);
• float cabsf(float complex z);
• long double cabsl(long double complex z);

Winkel φ bestimmen

• double carg(double complex z);
• float cargf(float complex z);
• long double cargl(long double complex z);

Komplexe Konjugation

• double complex conj(double complex z);
• float complex conjf(float complex z);
• long double complex conjl(long double complex z);

Wurzel

• double complex csqrt(double complex z);
• float complex csqrtf(float complex z);
• long double complex csqrtl(long double complex z);

Sinus

• double complex csin(double complex z);
• float complex csinf(float complex z);
• long double complex csinl(long double complex z);

Kosinus

• double complex ccos(double complex z);
• float complex ccosf(float complex z);
• long double complex ccosl(long double complex z);

Tangens

• double complex ctan(double complex z);
• float complex ctanf(float complex z);
• long double complex ctanl(long double complex z);

Exponentialfunktion

• double complex cpow(double complex x, complex double z);
• float complex cpowf(float complex x, complex float z);
• long double complex cpowl(long double complex x, complex long double z);

natürliche Exponentialfunktion

• double complex cexp(double complex z);
• float complex cexpf(float complex z);
• long double complex cexpl(long double complex z);

natürlicher Logarithmus

• double complex clog(double complex z);
• float complex clogf(float complex z);
• long double complex clogl(long double complex z);

fenv.h

• int feclearexcept(int excepts);
• int fegetexceptflag(fexcept_t *flagp, int excepts);
• int feraiseexcept(int excepts);
• int fesetexceptflag(const fexcept_t *flagp, int excepts);
• int fetestexcept(int excepts);
• int fegetround(void);
• int fesetround(int rounding_mode);
• int fegetenv(fenv_t *envp);
• int feholdexcept(fenv_t *envp);
• int fesetenv(const fenv_t *envp);
• int feupdateenv(const fenv_t *envp);

stdbool.h

Definiert den logischen Typ bool äquivalent zu _Bool sowie die Integerkonstanten true,false.