Anhang B Funktionsreferenz

Hier finden Sie eine kleine Referenz vieler Funktionen, die im Buch verwendet wurden. Da die meisten Funktionen recht ausführlich beschrieben wurden, wird hier meistens nur noch die Syntax angegeben – was gewöhnlich auch ausreicht, um diese anzuwenden. Benötigen Sie mehr Informationen zu einer Funktion, dann sollte Sie zum entsprechenden Kapitel blättern. Funktionen, die im Buch nicht oder nur kurz erwähnt bzw. verwendet wurden, werden etwas umfangreicher beschrieben.

Reichen Ihnen diese Informationen im Buch nicht aus, finden Sie immer noch Hilfe in den entsprechenden Manual-Pages. Meisten reicht hierfür ein einfaches man <funktionsname> aus.

B.1 ANSI C 

Zur Entstehungsgeschichte von C muss ich Ihnen wahrscheinlich nicht mehr viel erzählen. Das in C ein Standard nötig wurde, begründete sich dadurch, dass in den 70ern und 80ern C immer mehr verwendet wurde und mit der Zeit jeder seine eigenen Bibliotheken entwickelte, mit dem Nachteil, dass diese oft nur auf dem System ausgeführt werden konnten, auf denen diese entwickelt wurden. Was auf dem einen Rechner lief, funktionierte auf dem anderen Rechner gar nicht mehr und musste (fast) komplett neu geschrieben werden. 1983 sprang hierfür (wie für so vieles andere auch) ANSI (American National Standards Institute) ein und gründete ein Komitee, welches aus C einen Standard reformieren sollte, heute besser bekannt als ANSI C Standard.

1989 wurde dann dieser Standard zum ersten Mal veröffentlicht, weshalb auch hier oft vom C89-Standard die Rede ist. Teil des ANSI C Standards sind die Software Bibliotheken (besser bekannt unter dem Begriff ANSI C standard library).

Bei einer späteren Revisionen des C Standards wurden neue Headerdateien zur Bibliothek hinzugefügt. 1995 kamen bspw. die Headerdateien <iso646.h>, <wchar.h> und <wctype.h> hinzu, welche als Normative Amendment 1 bezeichnet wurden (kurz NA1).

Vier Jahre später, 1999, kamen dann die Headerdateien <complex.h>, <fenv.h>, <inttypes.h>, <stdbool.h>, <stdint.h> und <tgmath.h> hinzu. Diese Revision wurde dann als C99-Standard bekannt.

Natürlich wurden nicht immer nur Headerdateien hinzugefügt, sondern auch die wesentlichen Schwächen von C verbessert. Dies muss an dieser Stelle erwähnt werden, da häufig auf Titeln von Büchern zu lesen ist: »Entspricht dem neuen C99-Standard«. Häufig bezieht sich diese Aussage auf die wesentlichen Verbesserungen von C und nicht auf die neuen Bibliotheken.

B.1.1 <assert.h> – Testmöglichkeiten in einem Programm 

Syntax:

#include <assert.h>
void assert( int expression ) ;

Makro zur Überprüfung des skalaren Ausdrucks expression. Ist dieser Ausdruck gleich 0 und somit falsch, wird der Ausdruck samt Funktionsname, Dateiname, Zeilennummer auf die Standardfehlerausgabe ausgegeben und das Programm mittels abort() beendet. Wenn der Ausdruck hingegen ungleich 0 ist, läuft das Programm weiter wie bisher.

Die Testmöglichkeiten von assert() können mit dem Setzen des Makros NDEBUG ignoriert werden. Ist auf Ihrem System kein solches Makro definiert, können Sie assert() auch recht schnell von Hand wie folgt ausschalten:

#define assert(ignore)((void) 0)

B.1.2 <ctype.h> – Zeichenklassifizierung/Umwandlung 

Alle Funktionen, abgesehen von tolower() und toupper(), liefern als Rückgabewert bei Wahrheit einen Wert ungleich 0, ansonsten, wenn der Ausdruck nicht übereinstimmt, 0 zurück. Die Funktionen tolower() und toupper() geben bei Erfolg den umgewandelten Groß- bzw. Kleinbuchstaben zurück, ansonsten wird das Zeichen ch unverändert zurückgegeben. Als Argument erwarten alle Funktionen ein Zeichen, dessen Code sich zwischen 0 und 255 (oder EOF) befindet.

ANSI C 99: In der Headerdatei wctype.h befinden sich außerdem noch die Funktionen is... und tow..., welche zur Klassifizierung und Umwandlung von wchar_t-Typen verwendet werden. Hier liegt (logischerweise) der Wert der Argumente zwischen 0 und 32767 (oder WEOF). Der Aufruf der wchar_t-Typ-Funktionen in wctype.h ist ansonsten gleich wie schon bei ctype.h.

B.1.3 <errno.h> – Fehler-Konstanten 

Beim Auftreten eines Fehlers kann der genauere Grund des Fehlers mithilfe einer Abfrage des Rückgabewertes und der Integer-Variable errno ermittelt werden. Dafür befinden sich in der Headerdatei errno.h eine Menge Konstanten, welche alle mit dem Buchstaben E… beginnen. Diese Konstanten sind Fehlerwerte, wovon allerdings nur zwei dem ANSI C Standard entsprechen.

Hierzu noch eine Liste weiterer gängigere (häufiger auftretender) Fehlerwerte. Für eine umfangreichere Liste und Beschreibung der Fehlerwerte sei die Manual-Page zu intro (intro(2)) empfohlen.

B.1.4 <float.h> – Eigenschaften und Limits für Gleitpunkttypen 

B.1.5 <limits.h> – Limits, Konstanten 

B.1.6 <locale.h> – Länderspezifische Eigenheiten 

In ANSI C sind auch Funktionen vorhanden, die die länderspezifischen Eigenheiten wie bspw. die Formatierung von Geldbeträgen beachten. Dabei handelt es sich um zwei Funktionen und mehrere Makros, die recht selten Beachtung finden.

Wenn Sie ein Programm starten, werden die lokalen Aspekte zunächst nicht berücksichtigt und das Programm wird somit mit den Standard-Einstellungen der Umgebung gestartet.

Die Funktion, mit der Sie ein Programm mit den lokalen Eigenheiten zur Laufzeit anpassen können, lautet:

#include <locale.h>
char *setlocale( int kategorie, const char *name );

Manchmal will man nicht die kompletten lokalen Aspekte berücksichtigen, daher wurde die Kategorie (erstes Argument) folgendermaßen aufgeteilt:

Für das Argument name in der Funktion setlocale() sind folgende Angaben möglich:

Hierzu ein einfaches Beispiel, womit die lokale Umgebung ermittelt wird, dann anschließend entsprechend dem Einsatzgebiet des Compilers verändert und zum Schluss wieder hergestellt wird.

/* my_setlocale.c */
#include <stdio.h>
#include <locale.h>
#define KOMMA 3.3223
int main(void) {
   char *local_save = setlocale(LC_ALL, NULL);
   char *local;
   printf("Lokale Umgebung: %s (Standard)\n", local_save);
   printf("Gleitpunkt: %f\n",KOMMA);
   
   local = setlocale( LC_ALL, "");
   printf("Neue lokale Umgebung: %s\n", local);
   printf("Gleitpunkt: %f\n",KOMMA);
   
   printf("Standard-Umgebung Wiederherstellen\n");
   local = setlocale( LC_ALL, local_save);
   printf("Lokale Umgebung: %s (Wiederhergestellt)\n", local);
   return 0;
}

Die (mögliche) Ausgabe des Programms:

Lokale Umgebung: C (Standard)
Gleitpunkt: 3.322300
Neue lokale Umgebung: German_Germany.1252
Gleitpunkt: 3,322300
Standard-Umgebung Wiederherstellen
Lokale Umgebung: C (Wiederhergestellt)

Benötigen Sie außerdem Informationen für die Formatierung von numerischen Werten wie z. B. Dezimalpunkt oder dem Währungssymbol, steht Ihnen noch folgende Funktion zur Verfügung:

#include <locale.h>
struct lconv *localeconv( void );

Die Funktion füllt eine Struktur Namens lconv mit der aktuell gesetzten länderspezifischen Umgebung. Diese Struktur beinhaltet folgende Mitglieder:

struct lconv {
 char* decimal_point; /* Zeichen Dezimalpunkt                 */
 char* thousands_sep; /* Trennzeichen für Gruppen von Ziffern */ 
 char* grouping;      /* Größe einer Gruppe von Ziffern       */
 char* int_curr_symbol; /* Intern. Symbol für lokale Währung  */
 char* currency_symbol; /* lokales Währungssymbol             */
/* Zeichen Dezimalpunkt b. Geldbeträge */
 char* mon_decimal_point; 
/* Trennzeichen für Gruppen von Ziffern bei Geldbeträgen */
 char*   mon_thousands_sep; 
/* Größe einer Gruppe von Ziffern bei Geldbeträgen */
 char*   mon_grouping; 
 char*   positive_sign; /* Symbol für positive Geldbeträge */
 char*   negative_sign; /* Symbol für negative Geldbeträge */
/* Anzahl der Ziffern nach Dezimalpunkt von Geldbeträgen   */
/* (international) (meistens 2)                            */
 char   int_frac_digits; 
/* Anzahl der Ziffern nach Dezimalpunkt von Geldbeträgen   */
/* (national) (meistens 2)                                 */
 char   frac_digits; 
/* Für positive Geldbeträge  0=Währungssymbol nach dem Betrag; */
/*  1=Währungssymbol vor dem Betrag                            */
 char   p_cs_precedes; 
/* Für pos. Geldbeträge Leerzeichen zwischen Währungssymbol */
/* und dem Betrag: 1=Leerzeichen; 0=kein Leerzeichen        */
 char   p_sep_by_space; 
/* Für negative Geldbeträge  0=Währungssymbol nach dem Betrag */
/* 1=Währungssymbol vor dem Betrag                            */
 char   n_cs_precedes; 
/* Für negative Geldbeträge. Leerzeichen zwischen  */
/* Währungssymbol und dem Betrag: 1=Leerzeichen;   */
/* 0=kein Leerzeichen                              */
 char   n_sep_by_space; 
 char   p_sign_posn; /* Position von positive_sign */
 char   n_sign_posn; /* Position von negative_sign */
};

B.1.7 <math.h> – Mathematische Funktionen 

B.1.8 <setjmp.h> – Nicht-lokale Sprünge 

Gewöhnlich ist es ja nicht möglich, von einer aufgerufenen Funktion in die aufrufende Funktion zurückzugehen. Mit den Funktionen setjmp() und longjmp() hingegen ist ein solcher Rücksprung möglich.

Dabei wird mit setjmp() ein solcher Punkt im Programm festgelegt, der alle Informationen enthält, die nötig sind, um mit longjmp() aus einer beliebigen Stelle im Programm an diesen Punkt zurückzuspringen. Beim Setzen des Punktes mit setjmp() liefert diese Funktion den Wert 0 zurück, wenn alles richtig verlief. Wird setjmp() mit einem Funktionsaufruf von longjmp() – womit ja zu setjmp() zurückgesprungen wird – zum zweiten Mal durchlaufen, wird ein Wert ungleich 0 zurückgegeben.

Der Programmzustand, der von setjmp() gesetzt und von longjmp() angesprungen wird, wird in einem Puffer vom Typ jmp_buf gespeichert. Bei jmp_buf handelt es sich um ein Array mit Informationen wie u. a. Register-Inhalte, Instruktions-Pointer oder Stackpointer.

Problematisch könnte das Setzen eines Punktes mittels setjmp() werden, wenn longjmp() zu einem Punkt zurückspringen will, welcher in einer Funktion gesetzt wurde, die sich längst beendet hat. Dann ist das weitere Verhalten undefiniert.

Eine Anmerkung, unabhängig davon, was der ANSI C Standard vorschreibt, zu den Variablen bei nicht-lokalen Sprüngen. Diese behalten nach einem longjmp()-Aufruf gewöhnlich den neuen Wert, wenn die Variable sich nicht in einem Register der CPU befand. Die Variablen, die sich hingegen in einem CPU-Register befanden, erhalten den alten Wert, den diese beim setjmp()-Aufruf hatten. Dies ist zumindest beim GCC der Fall. Hierzu ein kurzer Codeausschnitt der Verwendung eines nicht-lokalen Sprungs:

...
jmp_buf programmzustand;
...
if(setjmp(programmzustand)==0)
    printf("Programmzustand auf den Stack gelegt\n");
else
    printf("Rücksprung mit longjmp erfolgt\n");
...
...
/* viele, viele Funktionen später */
longjmp(programmzustand,1);

B.1.9 <signal.h> – Signale 

Aufgrund einiger Schwächen der »alten« signal()-Funktion von ANSI C, sei hier auf die Referenz B.9 hingewiesen, wo das neue Signalkonzept behandelt wird.

B.1.10 <stdarg.h> – Variabel lange Argumentenliste 

Um eigene Funktionen mit einer variablen Argumentenliste zu schreiben, sind in der Headerdatei stdarg.h folgende vier Makros deklariert:

Hierzu ein einfaches Beispiel, welches mehrere Stings bis zu MAX-Zeichen aneinander hängt. Eine erweitertes strcat(), wenn Sie so wollen.

/* strxcat.c */
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#define MAX 50
void strxcat(int n_strings, ...) {
   va_list zeiger;
   char *quelle, *ziel, *p;
   va_start(zeiger,n_strings);
   /*Nun auf den Zielstring*/
   ziel = va_arg(zeiger,char *);
   p = ziel;
   /*Am Ende vom Zielstring*/
   ziel+=strlen(ziel);
   if((ziel-p) > MAX) {
         printf("!!!Max. Anzahl Zeichen Überschritten!!!\n");
         return;
   }
   while(--n_strings > 0) {
         /*Quelle einlesen*/
         quelle=va_arg(zeiger, char *);
         /*Jetzt Zeichen für Zeichen an ziel*/
         while(*quelle) {
               *ziel++ = *quelle++;
               if( (ziel-p) > MAX) {
                     printf("!Max. Zeichen ueberschritten!\n");
                     exit(EXIT_FAILURE);
               }
         }
   }
   *ziel = '\0';
}
int main(void) {
   char string[MAX] = "Test : ";
   char string2[] = " Und";
   strxcat(3, string, "hallo " , "welt");
   printf("%s\n",string);
   strxcat(5, string, string2, " noch", " ein", " Test");
   printf("%s\n",string);
   /*Und nun ein Fehler mit Absicht*/
   strxcat(4, string , " Ueberlauf", " von", " MAX");
   printf("%s\n",string);
   return EXIT_SUCCESS;
}

B.1.11 <stddef.h> – Standarddefinitionen 

In dieser Headerdatei finden Sie das Makro offsetof(), womit Sie den Abstand innerhalb einer Struktur von einzelnen Strukturelementen in Bytes ermitteln können. Ist dieses Makro bei Ihnen nicht vorhanden, lässt sich dies ohne großen Aufwand selbst implementieren:

#define offsetof(struct_type, member) \
          (size_t) &(((struct_type *)0)->member)

Ein einfaches Beispiel hierzu:

/* offsetof.c */
#include <stdio.h>
#include <stddef.h>
#define MAX 15
struct data {
   char a;
   int b;
   float c;
   double d;
 };
int main(void) {
   struct data newfile = { 'a', 1, 1.234, 3E5 };
   struct data *str_ptr = &newfile;
   int offset;
   
   printf("Start a (%d Bytes)"  ,offsetof(struct data, a));
   printf(" bis b == %d Bytes\n",offsetof(struct data, b));
   printf("Start b (%d Bytes)"  ,offsetof(struct data, b));
   printf(" bis d == %d Bytes\n",offsetof(struct data, d));
   printf("Komplett von Start a (%d Bytes)",
      offsetof(struct data, a));
   printf(" bis Ende d == %d Bytes\n",
      offsetof(struct data, d) + sizeof(double));
   return 0;
}

B.1.12 <stdio.h> – Standard Ein-/Ausgabe-Funktionen 

B.1.13 <stdlib.h> – Nützliche Funktionen (gemischt) 

B.1.14 <string.h> – String-Bearbeitungsfunktionen 

B.1.15 <time.h> – Datum und Uhrzeit