Rheinwerk Computing < openbook > Rheinwerk Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger

 << zurück
Linux-UNIX-Programmierung von Jürgen Wolf
Das umfassende Handbuch – 2., aktualisierte und erweiterte Auflage 2006
Buch: Linux-UNIX-Programmierung

Linux-UNIX-Programmierung
1216 S., mit CD, 49,90 Euro
Rheinwerk Computing
ISBN 3-89842-749-8
gp Kapitel B Funktionsreferenz
  gp B.1 ANSI C
  gp B.2 ANSI C99
  gp B.3 Elementare E/A-Funktionen
  gp B.4 Fortgeschrittene Ein-/Ausgabe-Funktionen
  gp B.5 Verzeichnisse
  gp B.6 Attribute von Dateien und Verzeichnissen
  gp B.7 Links
  gp B.8 Prozess und Prozessverwaltungsfunktionen
  gp B.9 Signale – Das neue Signalkonzept
  gp B.10 Interprozesskommunikationen
  gp B.11 Sys-V-Interprozesskommnunikationen
  gp B.12 Threadprogrammierung
  gp B.13 Netzwerkprogrammierung
  gp B.14 MySQL C-API
  gp B.15 PostgreSQL C-API
  gp B.16 Weitere Funktionsreferenzen auf der Buch-CD

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.


Rheinwerk Computing

B.1 ANSI C  downtop

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.


Rheinwerk Computing

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

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)

Rheinwerk Computing

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


Tabelle B.1    Funktionen der Headerdatei ctype.h

Bedeutung Funktion
Testet auf alphanumerisches Zeichen int isalnum(int ch);
Testet auf Zeichen des Alphabets int isalpha(int ch);
Testet auf Steuerzeichen int iscntrl(int ch);
Testet auf eine Ziffer int isdigit(int ch);
Testet auf druckbares Zeichen (ohne Leerzeichen) int isgraph(int ch);
Testet auf Kleinbuchstabe int islower(int ch);
Testet auf druckbares Zeichen int isprint(int ch);
Testet auf Interpunktionszeichen int ispunct(int ch);
Testet auf Zwischenraum-Zeichen (\n \t \v \r \f, Leerzeichen) int isspace(int ch);
Testet auf Großbuchstabe int isupper(int ch);
Testet auf eine hexadezimale Ziffer int isxdigit(int ch);
Testet auf ein ASCII-Zeichen int isascii(int ch);
Wandelt das Zeichen in einen Kleinbuchstaben um int tolower(int ch);
Wandelt das Zeichen in einen Großbuchstaben um int toupper(int ch);

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.


Hinweis   Zum Umwandeln eines Zeichens vom Typ wchar_t nach unsigned char wird die Funktion wctob() und umgekehrt, die Funktion btowc() verwendet.



Rheinwerk Computing

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

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.


Tabelle B.2    Fehlerkonstanten, die vom Standard gefordert werden

Konstante Bedeutung
EDOM Unzulässiges Argument für eine mathematische Funktion
ERANGE Ergebnis außerhalb des darstellbaren Bereichs

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.


Tabelle B.3    Fehlerbehandlungs-Konstanten bei Systemaufrufen

Fehlercode Bedeutung
EZERO Fehler 0
EINVFNC Ungültige Funktionsnummer
ENOFILE Datei nicht gefunden
ENOPATH Pfad nicht gefunden
ECONTR Speicherblöcke zerstört
EINVMEM Ungültige Speicherblockadresse
EINVENV Ungültiges Environment
EINVFMT Ungültiges Format
EINVACC Ungültiger Zugriffscode
EINVDAT Ungültige Daten
EINVDRV Ungültige Laufwerksangabe
ECURDIR Versuch, das aktuelle Verzeichnis zu löschen
ENOTSAM Nicht das gleiche Gerät
ENMFILE Keine weiteren Dateien mehr
ENOENT Datei oder Verzeichnis existiert nicht
EMFILE Zu viele geöffnete Dateien
EACCES Zugriff verweigert
EBADF Ungültiger Datei-Deskriptor
ENOMEM Zu wenig Speicher
ENODEV Gerät existiert nicht
EINVAL Ungültiges Argument
E2BIG Argumentliste ist zu lang
ENOEXEC Fehler beim Exec-Format
EXDEV Kreuzverbindung von Geräten
EFAULT Unbekannter Fehler
EEXIST Datei existiert bereits


Rheinwerk Computing

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


Tabelle B.4    Limit-Konstanten für Gleitpunkt-Datentypen in <float.h>

Konstante Bedeutung
FLT_RADIX Basis für Exponentendarstellung
FLT_MANT_DIG Anzahl Mantissenstellen (float)
DBL_MANT_DIG Anzahl Mantissenstellen (double)
LDBL_MANT_DIG Anzahl Mantissenstellen (long double)
FLT_DIG Genauigkeit in Dezimalziffern (float)
DBL_DIG Genauigkeit in Dezimalziffern (double)
LDBL_DIG Genauigkeit in Dezimalziffern (long double)
FLT_MIN_EXP Minimalster negativer FLT_RADIX-Exponent (float)
DBL_MIN_EXP Minimalster negativer FLT_RADIX-Exponent (double)
LDBL_MIN_EXP Minimalster negativer FLT_RADIX-Exponent (long double)
FLT_MIN_10_EXP Minimalster negativer Zehnerexponent (float)
DBL_MIN_10_EXP Minimalster negativer Zehnerexponent (double)
LDBL_MIN_10_EXP Minimalster negativer Zehnerexponent (long double)
FLT_MAX_EXP Maximaler FLT_RADIX-Exponent (float)
DBL_MAX_EXP Maximaler FLT_RADIX-Exponent (double)
LDBL_MAX_EXP Maximaler FLT_RADIX-Exponent (long double)
FLT_MAX_10_EXP Maximaler Zehnerexponent (float)
DBL_MAX_10_EXP Maximaler Zehnerexponent (double)
LDBL_MAX_10_EXP Maximaler Zehnerexponent (long double)
FLT_MAX Maximaler Gleitpunktwert (float)
DBL_MAX Maximaler Gleitpunktwert (double)
LDBL_MAX Maximaler Gleitpunktwert (long double)
FLT_EPSILON Kleinster float-Wert x für den 1.0 + x ungleich 1.0 gilt
DBL_EPSILON Kleinster double-Wert x für den 1.0 + x ungleich 1.0 gilt
LDBL_EPSILON Kleinster long double-Wert x für den 1.0 + x ungleich 1.0 gilt
FLT_MIN Minimalster normalisierter Gleitpunktwert (float)
DBL_MIN Minimalster normalisierter Gleitpunktwert (double)
LDBL_MIN Minimalster normalisierter Gleitpunktwert (long double)


Rheinwerk Computing

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


Tabelle B.5    Limit-Konstanten für ganzzahlige Datentypen in <limits.h>

Konstante Mindestwert Erklärung
CHAR_BIT 8 Bitzahl für ein Byte
SCHAR_MIN –127 min. signed char
SCHAR_MAX +127 max. signed char
UCHAR_MAX 255 max. unsigned char
CHAR_MIN SCHAR_MIN oder 0 min. char
CHAR_MAX SCHAR_MAX oder UCHAR_MAX max. char
MB_LEN_MAX 1 max. Byte für ein Viel-Bytezeichen
SHRT_MIN –32767 min. short int
SHRT_MAX +32767 max short int
USHRT_MAX 65535 max. unsigned short
INT_MIN –32767 (32 Bit: –2147483647) min. int
INT_MAX +32767 (32 Bit: +2147483647) max. int
UINT_MAX 65535 (32 Bit: 4294967295) max. unsigned int
LONG_MIN –2147483647 min. long int
LONG_MAX +2147483647 max. long int
ULONG_MAX 4294967295 max. unsigned long int


Rheinwerk Computing

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

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:


Tabelle B.6    Kategorien zu Lokalisierung der Umgebung

Kategorie Betroffen davon im Programm
LC_ALL alle lokalen Aspekte (die gleich noch in der Kategorie folgen) werden berücksichtigt
LC_COLLATE nur die Funktionen strcoll() und strxfrm()
LC_CTYPE nur die Funktionen für die Zeichenbehandlung in ctype.h bzw. wctype.h
LC_MONETARY die Formatierungs-Informationen für die Darstellung von Geldberägen (siehe localeconv())
LC_NUMERIC das Zeichen für den Dezimalpunkt der Ein/Ausgabe und Stringkonvertierungen
LC_TIME die Funktion strftime()

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


Tabelle B.7    Zweites Argument für setlocale()

Angabe für name Bedeutung
"C" Keine lokalen Aspekte werden berücksichtigt.
"" Einstellung richtet sich nach der Umgebung des Compilers.
NULL Die lokale Umgebung wird nicht verändert. Wird verwendet, um mithilfe des Rückgabewertes von setlocale() die alte Umgebung zu sichern und eventuell wiederherszustellen.

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

Rheinwerk Computing

B.1.7 <math.h> – Mathematische Funktionedowntop


Tabelle B.8    Mathematische Funktionen

Funktion Beschreibung
double acos (double zahl) Arcuscosinus
double asin (double zahl) Arcussinus
double atan (double zahl) Arcustangens
double atan2 (double zahl1, double zahl2) Arcustangens von zahl1 und zahl2
double cos (double zahl) Cosinus
double sin (double zahl) Sinus
double tan (double zahl) Tangens
double cosh (double zahl) Cosinus hyperbolicus
double sinh (double zahl) Sinus hypberbolicus
double tanh (double zahl) Tangens hypberbolicus
double exp (double zahl) Exponentialfunktion berechnen
double log (double zahl) Logarithmus von zahl zur Basis e = 2.71828...
double log10 (double zahl) Logarithmus zur Basis 10
double sqrt (double zahl) Quadratwurzel
double ceil (double zahl) Gleitpunktzahl aufrunden
double fabs (double zahl) Absolutwert
double floor (double zahl) Gleitpunktzahl abrunden
double frexp (double zahl, int zahl2) Zerlegt zahl in eine Mantisse und einen ganzzahligen Exponenten
double modf (double1 zahl1, double2 *zahl2) Zerlegt den Wert von zahl1 in einen gebrochenen und einen ganzzahligen Wert. Der ganzzahlige Wert (Vorkommateil) befindet sich dann in der Adresse von zahl2.
double pow (double zahl1, double zahl2) Potenz zahl1zahl2 
int fmod (double zahl1, double zahl2) float modulo errechnet den Rest von zahl1/zahl2


Rheinwerk Computing

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


Tabelle B.9    Funktionen für nicht-lokale Sprünge

Funktion Bedeutung
int setjmp(jmp_buf env); Einen Programmzustand abspeichern
void longjmp( jmp_buf env, int wert ); Den Programmzustand wieder herstellen

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

Rheinwerk Computing

B.1.9 <signal.h> – Signaldowntop

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.


Rheinwerk Computing

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

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


Tabelle B.10    Makros der Headerdatei stdarg.h

Makro Bedeutung
va_list ap; Liste der Parameter definieren
va_start(va_list ap, args); Argumentenliste mit dem ersten Argument initialisieren
type va_arg(va_list ap, type); Nächsten Parameter aus der Liste lesen
void va_end(va_list ap); Argumentlesevorgang beenden

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;
}

Rheinwerk Computing

B.1.11 <stddef.h> – Standarddefinitionedowntop

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;
}

Rheinwerk Computing

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


Tabelle B.11    Standard Ein-/Ausgabe-Funktionen

Syntax Bedeutung
FILE *fopen( const char *pfad, const char *modus); Datei öffnen
FILE *freopen( const char *pfad, const char *modus, FILE *fz); Datei öffnen mit bereits vorhandenem Stream
int fflush(FILE *fz); Inhalt des Datei-Puffers in einen Stream schreiben
int fclose(FILE *fz); Datei schließen
int remove( const char *pfadname); Datei löschen
int rename( const char *alt, const char *neu); Datei umbenennen
FILE *tmpfile(void); Temporäre Datei erzeugen und automatisch wieder löschen
char *tmpnam(char *ptr); Eindeutigen Namen für eine temporäre Datei erzeugen
void setbuf( FILE *fz, char *puffer); Einer Datei einen Puffer zuordnen
int setvbuf( FILE *fz, char *puffer, int modus, size_t size); Einer geöffneten Datei einen Puffer zuordnen
int fscanf( FILE *fz, const char *format, ...); Formatiert aus einem Stream lesen
int scanf( const char *format, ...); Formatiert aus der Standardeingabe (stdin) lesen
int sscanf( const char *puffer, const char *format, ...); Formatiert aus einem String lesen
int fprintf( FILE *fz, const char *format, ...); Formatiert in einen Stream schreiben
int printf( const char *format, ...); Formatiert auf die Standardausgabe (stdout) schreiben
int sprintf( char *puffer, const char *format, ...); Formatiert in einen String schreiben
int vfprintf( FILE *fz, const char *format, va_list arg); Formatiert in einen Stream schreiben mit Argumentenzeiger
int vprintf( const char *format, va_list arg); Formatiert auf stdout schreiben mit Argumentenzeiger
int vsprintf( char *puffer, const char *format, va_list arg); Formatiert in einen String schreiben mit Argumentenzeiger
int getchar(void); Ein Zeichen von der Standardeingabe (stdin) einlesen
int putchar(int ch); Ein Zeichen auf die Standardausgabe (stdout) schreiben
int fgetc(FILE *fz); /* oder */ int getc(FILE *fz); Ein Zeichen von einem Stream einlesen
int fputc(int ch,FILE *fz); /* oder */ int putc(int ch,FILE *fz); Ein Zeichen in einen Stream schreiben
int ungetc( int zeichen, FILE *fz); Ein gelesenes Zeichen in den Stream zurückschieben
int gets(char *puffer); /* sicherere Alternat. fgets */ Eine ganze Zeile von der Standardeingabe einlesen
int puts(const char *puffer); Eine ganze Zeile auf die Standardausgabe schreiben
int fgets( char *puffer, int n, FILE *fz); Eine ganze Zeile aus einem Stream lesen
int fputs( const char *puffer, FILE *fz); Eine ganze Zeile in einen Stream schreiben
size_t fread( void *ptr, size_t size, size_t n_obj, FILE *fz); Binäres Lesen ganzer Blöcke
size_t fwrite(const void *p,size_t siz,size_t n_obj,FILE *fz); Binäres Schreiben ganzer Blöcke
int fseek( FILE *fz, long offset, int origin); Einen Stream positionieren
int ftell(FILE *fz); Die Position eines Streams abfragen
int fgetpos( FILE *fz, fpos_t *pos); Die Position eines Streams speichern
int fsetpos( FILE *fz, const fpos_t *pos); Einen Stream positionieren (Zweite Möglichkeit)
void rewind(FILE *fz); Den Stream zum Dateianfang zurücksetzen
int feof(FILE *fz); EOF-Flag überprüfen, ob der Stream am Dateiende ist
int ferror(FILE *fz); Fehler-Flag überprüfen, ob beim Stream ein Fehler auftrat
void clearerr(FILE *fz); Das Fehler- und EOF-Flag löschen
void perror(const char *str); Ausgabe einer zu errno gehörigen Fehlermeldung


Rheinwerk Computing

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


Tabelle B.12    Allgemeine, nützliche Funktionen

Syntax Bedeutung
double atof(const char *str); Einen String in einen double-Wert konvertieren
int atoi(const char *str); Einen String in einen int-Wert konvertieren
long int atol(const char *str); Einen String in einen long int-Wert konvertieren
double strtod( const char *str, char **endptr); Einen String in einen double-Wert konvertieren
long strtol( const char *str, char **endptr, int base); Einen String in einen long-Wert konvertieren
long strtoul( const char *str, char **endptr, int base); Einen String in einen unsigned long-Wert konvertieren
void *malloc(size_t size); Speicherplatz allokieren
void *calloc( size_t anzahl, size_t size); Speicherplatz allokieren
void *realloc( void *zeiger, size_t size); Speicherplatz allokieren
void free(void *ptr); Allokierten Speicherplatz wieder freigeben
int rand(void); Erzeugt Pseudo-Zufallszahl zwischen 0 und RAND_MAX
void srand(unsigned int start); Legt den Startpunkt für eine Pseudo-Zufallszahl fest
int atexit( void (* funktion) (void)); Eine Funktion zur Ende-Behandlung eintragen
void exit(int status); Normale Programmbeendigung
void abort(void); Nicht normale Programmbeendigung
int system(const char *str); Ein Kommando zur Ausführung an die Umgebung übergeben
char *getenv(const char *name); Aktuelle Umgebungsvariablen des Systems abfragen
div_t div( int zaehler, int nenner); Quotient und Rest einer Division berechnen (int)
ldiv_t ldiv( long zaehler, long nenner); Quotient und Rest einer Division berechnen (long)
int abs(int num); Absolutwert eines int-Arguments
long labs(long num); Absolutwert eines long-Arguments
void *bsearch( const void *key, const void *start, size_t n, size_t size, int (*cmp)( const void *, const void *) ); Binäre Suche
void qsort( void *array, size_t n, size_t size, int (*cmp)( const void *, const void *) ); Quicksort (Sortieren)


ANSI C99   Neu im ANSI C99-Standard sind die Funktionen atoll() und strtoll(), womit ein String in einen long long-Wert konvertiert werden kann. Ebenfalls neu ist die Funktion _Exit(), die ähnlich wie _exit() (nicht zu verwechseln mit exit()) ein Programm sofort beendet, und zwar ohne das Senden von Signalen oder der Ausführung von Funktionen, die mit atexit() eingerichtet wurden.



Rheinwerk Computing

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


Tabelle B.13    Funktionen zum Umgang mit Zeichenketten

Syntax Bedeutung
void memcpy( void *ziel, const void *quelle, size_t anzahl); Bestimmte Anzahl Bytes in Quelle nach Ziel kopieren
void memmove( void *ziel, const void *quelle, size_t anzahl); Wie memcpy, nur wird der korrekte Kopiervorgang garantiert
void memchr( const void *ptr, int zeichen, size_t bereich); Sucht ein bestimmtes Zeichen in einem bestimmten Bereich
void memset( const void *ptr, int zeichen, size_t bereich); Füllt einen bestimmten Bereich mit einem Zeichen
void memcmp( const void *s1, const void *s2, size_t anzahl); Vergleicht eine bestimmte Anzahl Bytes miteinander
int strcpy( char *ziel, const char *quelle); Einen String kopieren
char *strncpy( char *ziel, const char *quelle, size_t size); Eine bestimmte Anzahl von Zeichen eines Strings kopieren
char *strcat( char *str1, const char *str2); Einen String an einen anderen hängen
char *strncat( char *str1, char *str2, size_t size); Einen String bestimmter Länge an einen anderen hängen
int strcmp( const char *str1, const char *str2); Zwei Strings miteinander vergleichen
int strncmp( const char *str1, const char *str2, size_t size); Zwei Strings bis zu einer gewissen Länge vergleichen
size_t strlen(const char *str); Länge eines Strings ermitteln (ohne Stringende-Zeichen \0)
char *strchr( const char *str, int zeichen); Ein Zeichen in einem String suchen (von vorne)
char *strrchr( const char *str, int zeichen); Ein Zeichen in einem String suchen (von hinten)
char *strstr( const char *str, const char *such_str); Suchen einer bestimmten Stringfolge in einem String
char *strpbrk( const char *str, const char *zeichen_menge); Suchen eines Zeichens aus einer Zeichenmenge im String
size_t strspn( const char *str, const char *zeichen_menge); Ermittelt die Länge der übereinstimmenden Zeichen
size_t strcspn( const char *str, const char *zeichen_menge); Ermittelt die Anzahl der nicht übereinstimmenden Zeichen
char *strtok( char *str, const char *zeichen); Einen String nach bestimmten Zeichen zerlegen
char *strerror( int fehlernummer); Gibt eine zur Fehlernummer gehörende Fehlermeldung aus
int strcoll( const char*str1, const char *str2); Länderspezifische Vergleichsfunktion
size_t strxfrm( char *land, const char *is_land, size_t size); Länderspezifische Umwandlung von Zeichen


Rheinwerk Computing

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


Tabelle B.14    Zeit- und Datumsfunktionen

Syntax Bedeutung
clock_t clock(void); Verbrauchte CPU-Zeit seit dem Programmstart
time_t time(time_t *time_ptr); Erfragen der aktuellen Kalenderzeit
struct tm *gmtime( const time_t *time_ptr); struct tm *localtime( const time_t *time_ptr); Konvertieren vom time_t-Zeitformat zur struct tm-Zeit
time_t mktime( const struct tm *tm_ptr); Konvertieren vom struct tm-Zeitformat zur time_t-Zeit
char *asctime( const struct tm *tm_ptr); Konvertieren vom struct tm-Zeitformat in einen String
char *ctime( const time_t *time_ptr); Konvertieren vom time_t-Zeitformat in einen String
double difftime( time_t z2, time_t z1); Differenzen zweier Uhrzeiten im time_t-Format
size_t strftime( char *puf, size_t smax, const char *fmt, const struct tm *t_ptr); Konvertieren vom struct tm-Zeitformat in einen benutzerdefinierten String


Tabelle B.15    (Primitive) Datentypen und Struktur für Datum und Zeit

Typ Bedeutung
size_t arithmetischer Datentyp für Größenangaben
clock_t arithmetischer Datentyp für CPU-Zeit
time_t arithmetischer Datentyp für Datum- und Zeitangabe
struct tm enthält alle zu einer Kalenderzeit (gregorianische) relevanten Komponenten


Tabelle B.16    Bedeutung der Strukturvariablen in struct tm

struct tm-Variable Bedeutung
int tm_sec; Sekunden (0–59)
int tm_min; Minuten (0–59)
int tm_hour; Stunden (0–23)
int tm_mday; Monatstag (1–31)
int tm_mon; Monate (0–11) (Januar = 0)
int tm_year; ab 1900
int tm_wday; Tag seit Sonntag (0–6) (Sonntag =0)
int tm_yday; Tag seit 1. Januar (0–365) (1.Januar =0)
int tm_isdst; Sommerzeit (tm_isdst > 0) Winterzeit (tm_istdst == 0) nicht verfügbar (tm_isdst < 0)

 << zurück
  
  Zum Katalog
Zum Katalog: Linux-UNIX-Programmierung
Linux-UNIX-
Programmierung

bestellen
 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: Linux-Server






 Linux-Server


Zum Katalog: Das Komplettpaket LPIC-1 & LPIC-2






 Das Komplettpaket
 LPIC-1 & LPIC-2


Zum Katalog: Linux-Hochverfügbarkeit






 Linux-
 Hochverfügbarkeit


Zum Katalog: Shell-Programmierung






 Shell-
 Programmierung


Zum Katalog: Linux Handbuch






 Linux Handbuch


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
Info





Copyright © Rheinwerk Verlag GmbH 2006
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Rheinwerk Computing]

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de