@DATABASE StormReference.guide @$VER StormReference 1.1 (5.12.2000) @(C) Copyright 1995-2000 by HAAGE & PARTNER Computer GmbH @SMARTWRAP @TAB 3 @MACRO HEADER "@{b}@{FG Shine}" @MACRO UHEADER "@{FG Text}@{UB}@{PAR}" @MACRO SUBHDR "@{u}" @MACRO USUBHDR "@{uu}@{PAR}" @MACRO ENUM "@{b}" @MACRO UENUM "@{ub}" @MACRO FUNC "@{b}@{FG Shine}" @MACRO UFUNC "@{FG Text}@{ub}@{PAR}" @MACRO SYN "@{b}" @MACRO USYN "@{ub}@{PAR}" @MACRO PORT "@{b} @MACRO UPORT "@{ub}@{PAR}" @MACRO XPL "@{b}" @MACRO UXPL "@{ub}@{PAR}" @MACRO RSLT "@{b}" @MACRO URSLT "@{ub}@{PAR}" @MACRO ATT "@{b}" @MACRO UATT "@{ub}@{PAR}" @MACRO SEE "@{b}" @MACRO USEE "@{ub}@{PAR}" @MACRO XMPL "@{b}" @MACRO UXMPL "@{ub}@{PAR}" @MACRO MTHD "@{b}" @MACRO UMTHD "@{ub}@{PAR}" @MACRO MARK "@{u}" @MACRO UMARK "@{uu}" @MACRO LETTER "@{b}@{FG Shine}" @MACRO ULETTER "@{FG Text}@{ub}" @INDEX Index @NODE Main "Funktionsbibliotheken" @{HEADER}Referenz der ANSI-C und C++ Bibliothek zu StormC@{UHEADER} © 1996-2000 by HAAGE & PARTNER Computer GmbH@{PAR} @{HEADER}ANSI-C Funktionen@{UHEADER} @{SUBHDR}assert.h@{USUBHDR} @{" assert " LINK "assert"}@{PAR} @{SUBHDR}ctype.h@{USUBHDR} @{" isalnum " LINK "isalnum"} @{" isalpha " LINK "isalpha"} @{" iscntrl " LINK "iscntrl"}@{PAR} @{" isdigit " LINK "isdigit"} @{" isgraph " LINK "isgraph"} @{" islower " LINK "islower"}@{PAR} @{" isprint " LINK "isprint"} @{" ispunct " LINK "ispunct"} @{" isspace " LINK "isspace"}@{PAR} @{" istream " LINK "istream"} @{" isupper " LINK "isupper"} @{" isxdigit " LINK "isxdigit"}@{PAR} @{" tolower " LINK "tolower"} @{" toupper " LINK "toupper"}@{PAR} @{SUBHDR}math.h@{USUBHDR} @{" acos " LINK "acos"} @{" asin " LINK "asin"} @{" atan " LINK "atan"}@{PAR} @{" atan2 " LINK "atan2"} @{" ceil " LINK "ceil"} @{" cos " LINK "cos"}@{PAR} @{" cosh " LINK "cosh"} @{" exp " LINK "exp"} @{" fabs " LINK "fabs"}@{PAR} @{" floor " LINK "floor"} @{" fmod " LINK "fmod"} @{" frexp " LINK "frexp"}@{PAR} @{" ldexp " LINK "ldexp"} @{" log " LINK "log"} @{" log10 " LINK "log10"}@{PAR} @{" modf " LINK "modf"} @{" pow " LINK "pow"} @{" sin " LINK "sin"}@{PAR} @{" sinh " LINK "sinh"} @{" sqrt " LINK "sqrt"} @{" tan " LINK "tan"}@{PAR} @{" tanh " LINK "tanh"}@{PAR} @{SUBHDR}setjmp.h@{USUBHDR} @{" longjmp " LINK "longjmp"} @{" setjmp " LINK "setjmp"}@{PAR} @{SUBHDR}signal.h@{USUBHDR} @{" raise " LINK "raise"} @{" signal " LINK "signal"}@{PAR} @{SUBHDR}stdarg.h@{USUBHDR} @{" va_arg " LINK "va_arg"} @{" va_end " LINK "va_end"} @{" va_start " LINK "va_start"}@{PAR} @{SUBHDR}stddef.h@{USUBHDR} @{" offsetof " LINK "offsetof"}@{PAR} @{SUBHDR}stdio.h@{USUBHDR} @{" clearerr " LINK "clearerr"} @{" fclose " LINK "fclose"} @{" feof " LINK "feof"}@{PAR} @{" ferror " LINK "ferror"} @{" fflush " LINK "fflush"} @{" fgetc " LINK "fgetc"}@{PAR} @{" fgetpos " LINK "fgetpos"} @{" fgets " LINK "fgets"} @{" fopen " LINK "fopen"}@{PAR} @{" fprintf " LINK "fprintf"} @{" fputc " LINK "fputc"} @{" fputs " LINK "fputs"}@{PAR} @{" fread " LINK "fread"} @{" freopen " LINK "freopen"} @{" fscanf " LINK "fscanf"}@{PAR} @{" fseek " LINK "fseek"} @{" fsetpos " LINK "fsetpos"} @{" fstream " LINK "fstream"}@{PAR} @{" ftell " LINK "ftell"} @{" fwrite " LINK "fwrite"} @{" getc " LINK "getc"}@{PAR} @{" getchar " LINK "getchar"} @{" gets " LINK "gets"} @{" perror " LINK "perror"}@{PAR} @{" printf " LINK "printf"} @{" putc " LINK "putc"} @{" putchar " LINK "putchar"}@{PAR} @{" puts " LINK "puts"} @{" remove " LINK "remove"} @{" rename " LINK "rename"}@{PAR} @{" rewind " LINK "rewind"} @{" scanf " LINK "scanf"} @{" setbuf " LINK "setbuf"}@{PAR} @{" setvbuf " LINK "setvbuf"} @{" sprintf " LINK "sprintf"} @{" sscanf " LINK "sscanf"}@{PAR} @{" tmpfile " LINK "tmpfile"} @{" tmpnam " LINK "tmpnam"} @{" ungetc " LINK "ungetc"}@{PAR} @{" vfprintf " LINK "vfprintf"} @{" vprintf " LINK "vprintf"} @{" vsprintf " LINK "vsprintf"}@{PAR} @{SUBHDR}stdlib.h@{USUBHDR} @{" abort " LINK "abort"} @{" abs " LINK "abs"} @{" atexit " LINK "atexit"}@{PAR} @{" atof " LINK "atof"} @{" atoi " LINK "atoi"} @{" atol " LINK "atol"}@{PAR} @{" bsearch " LINK "bsearch"} @{" calloc " LINK "calloc"} @{" div " LINK "div"}@{PAR} @{" exit " LINK "exit"} @{" free " LINK "free"} @{" getenv " LINK "getenv"}@{PAR} @{" labs " LINK "labs"} @{" ldiv " LINK "ldiv"} @{" malloc " LINK "malloc"}@{PAR} @{" qsort " LINK "qsort"} @{" rand " LINK "rand"} @{" realloc " LINK "realloc"}@{PAR} @{" srand " LINK "srand"} @{" strtod " LINK "strtod"} @{" strtol " LINK "strtol"}@{PAR} @{" strtoul " LINK "strtoul"} @{" system " LINK "system"}@{PAR} @{SUBHDR}string.h@{USUBHDR} @{" memchr " LINK "memchr"} @{" memcmp " LINK "memcmp"} @{" memcpy " LINK "memcpy"}@{PAR} @{" memmove " LINK "memmove"} @{" memset " LINK "memset"} @{" strcat " LINK "strcat"}@{PAR} @{" strchr " LINK "strchr"} @{" strcmp " LINK "strcmp"} @{" strcpy " LINK "strcpy"}@{PAR} @{" strcspn " LINK "strcspn"} @{" strerror " LINK "strerror"} @{" stricmp " LINK "stricmp"}@{PAR} @{" strlen " LINK "strlen"} @{" strncat " LINK "strncat"} @{" strncmp " LINK "strncmp"}@{PAR} @{" strncpy " LINK "strncpy"} @{" strpbrk " LINK "strpbrk"} @{" strrchr " LINK "strrchr"}@{PAR} @{" strspn " LINK "strspn"} @{" strstr " LINK "strstr"} @{" strtok " LINK "strtok"}@{PAR} @{SUBHDR}time.h@{USUBHDR} @{" asctime " LINK "asctime"} @{" clock " LINK "clock"} @{" ctime " LINK "ctime"}@{PAR} @{" difftime " LINK "difftime"} @{" gmtime " LINK "gmtime"} @{" localtime " LINK "localtime"}@{PAR} @{" mktime " LINK "mktime"} @{" strftime " LINK "strftime"} @{" time " LINK "time"}@{PAR} @{HEADER}C++ Klassen@{UHEADER} @{" cerr " LINK "cerr"} @{" cin " LINK "cin"} @{" clog " LINK "clog"}@{PAR} @{" cout " LINK "cout"} @{" filebuf " LINK "filebuf"} @{" ifstream " LINK "ifstream"}@{PAR} @{" ios " LINK "ios"} @{" iostream " LINK "iostream"} @{" ofstream " LINK "ofstream"}@{PAR} @{" ostream " LINK "ostream"} @{" streambuf " LINK "streambuf"}@{PAR} @ENDNODE @NODE abort "abort" @{FUNC}abort@{UFUNC} Abbruch des Programms@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} void abort(void)@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Das Programm wird einfach abgebrochen, ganz ohne Aufruf von Destruktoren, @{" atexit " LINK "atexit"}-Funktionen und Ressourcen-Freigabe. Aus einer Shared-Library darf diese Funktion nicht aufgerufen werden.@{PAR} Der Rückgabewert an den Elternprozess (meist der aufrufende CLI) ist 3. Es wird keine Meldung über den Abbruch ausgegeben, allerdings kann die Funktion jederzeit über @{" signal " LINK "signal"} ausgetauscht werden. Die Standardfunktion heißt "abort_STANDARD" und muß per extern "ASM" angesprochen werden.@{PAR} @{SEE}Siehe auch@{USEE} @{" atexit " LINK "atexit"}, @{" exit " LINK "exit"}, @{" signal " LINK "signal"}@{PAR} @ENDNODE @NODE abs "abs" @{FUNC}abs@{UFUNC} Der absolute Wert einer Ganzzahl@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = abs(i);@{PAR} int r; // Ergebnis@{PAR} int i; // Ganzzahl@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "abs" liefert den absoluten Betrag seines Arguments, also so etwas wie "(i >= 0 ? +i : -i)". Die Funktion kann auch als Makro definiert werden:@{PAR} #define abs(x) ((x)<0?-(x):(x))@{PAR} @{RSLT}Rückgabe@{URSLT} Der absolute Betrag des Arguments.@{PAR} @{SEE}Siehe auch@{USEE} @{" fabs " LINK "fabs"}, @{" labs " LINK "labs"}@{PAR} @ENDNODE @NODE acos "acos" @{FUNC}acos@{UFUNC} Der Arcus Cosinus@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = acos(x);@{PAR} double r; // Ergebnis@{PAR} double x; // Winkel@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Der Arcus Cosinus ist die Umkehrfunktion zum Cosinus. Das heißt im Prinzip x = acos(cos(x)). Da der Cosinus eine periodische Funktion ist, muß man sich für seine Umkehrfunktion auf ein bestimmtes Bildintervall einigen. Beim Arcus Cosinus ist dies üblicherweise das Intervall [0,PI].@{PAR} @{ATT}Hinweis@{UATT} Bei den trigonometrichen Funktionen werden Winkel natürlich im Bogenmaß (Radian) angegeben. Ein Gradwinkel "w" läßt sich mit der Formel@{PAR} x = PI/180 * w@{PAR} in Bogenmaß umrechnen.@{PAR} @{SEE}Siehe auch@{USEE} @{" cos " LINK "cos"}, @{" asin " LINK "asin"}@{PAR} @ENDNODE @NODE asctime "asctime" @{FUNC}asctime@{UFUNC} Erzeugt eine Zeichenkette aus Datum und Zeit@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} tp = asctime (t);@{PAR} char *tp; // Adresse der Zeit-Zeichenkette@{PAR} const struct tm *t; // Adresse der tm-Struktur@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "asctime" ist eine Sparversion von "strftime" und wandelt die Zeit aus "*t" in eine Zeichenkette der Form "Tue Apr 07 01:03:42 1992" um. Diese Zeichenkette wird in einem internen Puffer abgelegt und ein Zeiger darauf zurückgegeben.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Funktion liefert einen ASCII-Text mit der exakten Länge von 26 Zeichen. Das Format des Textes ist:@{PAR} "DDD MMM dd hh:mm:ss YYYY\n\0"@{PAR} DDD ist der Wochentag, MMM ist der Monat, dd ist der Tag im Monat, hh:mm:ss sind Stunde:Minute:Sekunde und YYYY ist das Jahr. Zum Beispiel:@{PAR} "Wed Okt 25 12:05:43 1995\n\0"@{PAR} Der für den String reservierte Speicherbereich wird für die Funktionen "asctime" und "ctime" gleichermaßen verwendet.@{PAR} @{SEE}Siehe auch@{USEE} @{" ctime " LINK "ctime"}, @{" gmtime " LINK "gmtime"}, @{" localtime " LINK "localtime"}, @{" strftime " LINK "strftime"}, @{" time " LINK "time"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} void main(void)@{PAR} {@{PAR} struct tm *tp;@{PAR} time_t t;@{PAR} time(&t);@{PAR} tp = localtime(&t);@{PAR} printf("Die aktuelle Zeit ist %s\n",asctime(tp));@{PAR} }@{PAR} @ENDNODE @NODE asin "asin" @{FUNC}asin@{UFUNC} Der Arcus Sinus@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = asin(x)@{PAR} double r; // Ergebnis@{PAR} double x; // Winkel@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Der Arcus Sinus ist die Umkehrfunktion zum Sinus. Das heißt im Prinzip x = asin(sin(x)). Da der Cosinus eine periodische Funktion ist, muß man sich für seine Umkehrfunktion auf ein bestimmtes Bildintervall einigen. Beim Arcus Sinus ist dies üblicherweise das Intervall [-PI/2,PI/2].@{PAR} @{ATT}Hinweis@{UATT} Bei den trigonometrichen Funktionen werden Winkel natürlich im Bogenmaß (Radian) angegeben. Ein Gradwinkel "w" läßt sich mit der Formel@{PAR} x = PI/180 * w@{PAR} in Bogenmaß umrechnen.@{PAR} @{SEE}Siehe auch@{USEE} @{" sin " LINK "sin"}, @{" acos " LINK "acos"}@{PAR} @ENDNODE @NODE assert "assert" @{FUNC}assert@{UFUNC} Testet eine Bedingung und unterbricht den Programmlauf@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} assert(x);@{PAR} int x; // Ausdruck für die Bedingungsprüfung@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Include-Datei "assert.h" definiert lediglich ein einziges Makro nämlich assert. Man kann damit die Sicherheit seines Programms erhöhen, indem man Plausibilitätstests einführt. Wenn z. B. eine Funktion einen Parameter zwischen 0 und 5 erwartet, setze man an ihren Anfang folgendes:@{PAR} int f(int i)@{PAR} {@{PAR} assert(i>0 && i<5)@{PAR} }@{PAR} Gilt die bei assert angegebene Bedingung nicht, steigt das Programm bei einem ungültigen Parameter mit einer Meldung wie@{PAR} Assertion failed: i>0 && i<5, file "falsch.cc", line 1822@{PAR} aus - es sei denn, man definiert das Makro @{MARK}NDEBUG@{UMARK}, bevor man das Makro benutzt. In diesem Fall werden die assert-Anweisungen ersatzlos gestrichen und kosten so weder Laufzeit noch Speicherplatz. Man sollte NDEBUG immer erst dann definieren, wenn man der Meinung ist, das Programm sei fehlerfrei. Auf jeden Fall aber vermeide man Bedingungen mit Seiteneffekt.@{PAR} @{XMPL}Beispiel@{UXMPL} FILE *fp;@{PAR} assert(fp = fopen("S:supervisor-startup", "r")) // Ganz schlecht!@{PAR} Diese Anweisung gibt zwar eine mehr oder weniger aussagekräftige Fehlermeldung ab, wenn das Programm seine Konfigurationsdatei nicht finden kann, und steigt dann aus, was durchaus sinnvoll ist - aber irgendwann kommt man vielleicht doch noch auf die Idee, NDEBUG zu definieren, und dann wird man sich wundern.@{PAR} @ENDNODE @NODE atan "atan" @{FUNC}atan@{UFUNC} Arcus Tangens@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} d = atan(x);@{PAR} double d; // Ergebnis@{PAR} double x; // Winkel@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Funktione Arcus Tangens ist die Umkehrfunktion zum Tangens. Ihr Definitionsbereich ist -PI < x < +PI und ihr Wertebereich -PI/2 < y < +PI/2.@{PAR} @{ATT}Hinweis@{UATT} Bei den trigonometrichen Funktionen werden Winkel natürlich im Bogenmaß (Radian) angegeben. Ein Gradwinkel "w" läßt sich mit der Formel@{PAR} x = PI/180 * w@{PAR} in Bogenmaß umrechnen.@{PAR} @{SEE}Siehe auch@{USEE} @{" tan " LINK "tan"}, @{" acos " LINK "acos"}, @{" asin " LINK "asin"}@{PAR} @ENDNODE @NODE atan2 "atan2" @{FUNC}atan2@{UFUNC} Liefert den Arcustangens von x/y@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = atan2(x, y);@{PAR} double r; // Ergebnis@{PAR} double x; // Winkel@{PAR} double y; // Winkel@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Funktion atan2 berechnet den Arcustangens von x/y, d. h. den Winkel j, der zum Zahlenpaar "x = cos j" und "y = sin j" gehört. Das Ergebnis ist aus [-PI, +PI], und die Funktion ist besonders dann praktisch, wenn man kartesische in Polarkoordinaten umrechnen will.@{PAR} Die Umrechnung von kartesichen in Polarkoordinaten wird damit sehr einfach, da bei gegebenen Koordinaten x und y der Winkel der Radialen ermittelt werden kann.@{PAR} @{SEE}Siehe auch@{USEE} @{" atan " LINK "atan"}, @{" tan " LINK "tan"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} void main (void)@{PAR} {@{PAR} double result, x = 90.0, y = 15.0;@{PAR} result = atan2(y, x);@{PAR} printf("Der Arcustangens von %lf ist %lf\n",@{PAR} (y/x), result);@{PAR} }@{PAR} @ENDNODE @NODE atexit "atexit" @{FUNC}atexit@{UFUNC} Setzt Funktionen, die am Programmende ausgeführt werden.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} error = atexit(funktion);@{PAR} int error;@{PAR} void (*funktion)(void)@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Funktion atexit teilt der Laufzeitbibliothek mit, daß die angegebene parameterlose Funktion am Programmende ausgeführt werden soll. Dabei gibt es keine Grenze wieviele Funktionen angegeben werden. Der Aufruf der Funktion erfolgt in der umgekehrten Reihenfolge in der sie angemeldet wurden.@{PAR} Eine mit der Funktion atexit gesetzte Exit-Funktion kann nicht wieder entfernt werden.@{PAR} @{RSLT}Rückgabe@{URSLT} Wenn die Funktion erfolgreich installiert werden konnte, wird 0 zurückgeliefert. Anderenfalls einen Wert ungleich Null.@{PAR} @{SEE}Siehe auch@{USEE} @{" abort " LINK "abort"}, @{" exit " LINK "exit"}@{PAR} @ENDNODE @NODE atof "atof" @{FUNC}atof@{UFUNC} Konvertiert einen ASCII-Text in eine Fließkommazahl.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} x = atof(s);@{PAR} double x; // Ergebnis als Fließkommazahl@{PAR} const char *s; // Eingabe String-Zeiger@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion konvertiert einen ASCII-Text in eine doppeltgenaue Fließkommazahl. Ein Aufruf von "atof" ist äquivalent zu "strtod(string, 0)".@{PAR} Der ASCII-Text muß folgendes Format haben:@{PAR} [ws][sign]digits[.][digits][e|E[sign]digits]@{PAR} Dabei steht @{MARK}ws@{UMARK} für eine Folge von Whitespaces (Leerzeichen und Tabulatoren), @{MARK}sign@{UMARK} für ein Vorzeichen + oder - und @{MARK}digits@{UMARK} für eine Folge von Ziffern 0 bis 9. Alle Elemente in eckigen Klammer sind optional. Die Nachfolgende Zeichenfolge ist eine gültige Zahl:@{PAR} +123.456e-78@{PAR} @{RSLT}Rückgabe@{URSLT} Diese Funktion liefert das doppeltgenauen Fließkomma-Äquivalent des ASCII-Textes.@{PAR} Bei einem Überlauf wird plus oder minus HUGE_VAL geliefert. errno erhält den Wert ERANGE.@{PAR} @{SEE}Siehe auch@{USEE} @{" atoi " LINK "atoi"}, @{" atol " LINK "atol"}, @{" strtod " LINK "strtod"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} void main(void)@{PAR} { char buff[80];@{PAR} double d;@{PAR} while(1)@{PAR} { printf("\nBitte geben Sie eine Nummer ein: ");@{PAR} if(fgets(buff, sizeof(buff), stdin) == NULL)@{PAR} {@{PAR} break;@{PAR} } if(buff[0] == '\0')@{PAR} {@{PAR} break;@{PAR} } d = atof(buff);@{PAR} printf("%e\n",d);@{PAR} } printf("\n");@{PAR} }@{PAR} @ENDNODE @NODE atoi "atoi" @{FUNC}atoi@{UFUNC} Konvertiert einen ASCII-Text in eine Ganzzahl.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} x = atoi(s);@{PAR} int x;@{PAR} const char *s;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "atoi" wandelt eine dezimale Ziffernfolge in den entsprechenden numerischen Wert um und entspricht damit:@{PAR} (int) strtol(string, 0, 10)@{PAR} Der ASCII-Text muß in folgendem Format vorliegen:@{PAR} [ws][sign]digits@{PAR} Dabei steht @{MARK}ws@{UMARK}für eine Folge von Whitespaces (Leerzeichen und Tabulatoren), @{MARK}sign@{UMARK} für ein Vorzeichen + oder - und @{MARK}digits@{UMARK} für eine Folge von Ziffern 0 bis 9. Elemente in eckigen Klammern sind optional. Ein Integerüberlauf wird nicht geprüft.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Funktion liefert das Integer-Equivalent des ASCII-Textes. Falls der ASCII-Text nicht konvertiert werden kann, wird 0 zurückgeliefert.@{PAR} @{SEE}Siehe auch@{USEE} @{" atof " LINK "atof"}, @{" atol " LINK "atol"}, @{" strtod " LINK "strtod"}, @{" strtol " LINK "strtol"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} void main(void)@{PAR} {@{PAR} int x;@{PAR} char *cp = " 567";@{PAR} x = atoi(cp);@{PAR} printf("Gewandelt %d\n",x);@{PAR} }@{PAR} @ENDNODE @NODE atol "atol" @{FUNC}atol@{UFUNC} Konvertiert einen ASCII-Text in eine lange Ganzzahl.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} z = atol(s);@{PAR} long z;@{PAR} const char *s;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "atol" konvertiert einen ASCII-Text in eine lange Ganzzahl. Auch diese Funktion ist nur eine vereinfachte Form von "strtol" und entspricht "strtol(string, 0, 10)".@{PAR} Der ASCII-Text muß in folgendem Format vorliegen:@{PAR} [ws][sign]digits@{PAR} Dabei steht @{MARK}ws@{UMARK}für eine Folge von Whitespaces (Leerzeichen und Tabulatoren), @{MARK}sign@{UMARK} für ein Vorzeichen + oder - und @{MARK}digits@{UMARK} für eine Folge von Ziffern 0 bis 9. Elemente in eckigen Klammern sind optional. Ein Integerüberlauf wird nicht geprüft.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Funktion liefert das Integer-Equivalent des ASCII-Textes. Falls der ASCII-Text nicht konvertiert werden kann, wird 0 zurückgeliefert.@{PAR} @{SEE}Siehe auch@{USEE} @{" atof " LINK "atof"}, @{" atoi " LINK "atoi"}, @{" strtod " LINK "strtod"}, @{" strtol " LINK "strtol"}@{PAR} @ENDNODE @NODE bsearch "bsearch" @{FUNC}bsearch@{UFUNC} Binärer Suche in Feldern@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = bsearch(obj, vektor, anzahl, size, compare);@{PAR} void *r; // gefundenes Objekt const void *obj; // Objekt nach dem gesucht wird@{PAR} const void *vektor; // Zeiger auf das Suchfeld@{PAR} size_t anzahl; // Anzahl der Einträge im Suchfeld@{PAR} size_t size; // Größe der Einträge@{PAR} int (*compare)(const void *, const void *))@{PAR} // Zeiger auf die Vergleichsfunktion@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "bsearch" sucht im Vektor "vektor[0] ... vektor[anzahl-1]", dessen Elemente jeweils die Größe "size" haben, anhand der angegebenen Vergleichsfunktion ein Element, das mit "*obj" übereinstimmt. Da die Suche binär erfolgt, muß der Vektor dafür (z. B. mit "qsort") sortiert sein.@{PAR} Die Vergleichsfunktion "compare" muß folgende Ergebnisse liefern:@{PAR} · eine negative Ganzzahl, falls der erste der beiden Objekte kleiner ist als der zweite.@{PAR} · eine positive Ganzzahl, falls der ertse der beiden Objekte größer als der zweite ist.@{PAR} · 0 falls beide Objekte gleich sind@{PAR} @{RSLT}Rückgabe@{URSLT} Die Funktion liefert einen Zeiger auf das Element, das mit dem gesuchten übereinstimmt. Falls kein passendes Element gefunden werden kann, wird NULL geliefert.@{PAR} @{SEE}Siehe auch@{USEE} @{" qsort " LINK "qsort"}, @{" strcmp " LINK "strcmp"}@{PAR} @ENDNODE @NODE calloc "calloc" @{FUNC}calloc@{UFUNC} Speicher reservieren und initialisieren.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} b = calloc(anzahl, size);@{PAR} void *b; // Adresse des Speicherblocks@{PAR} size_t anzahl; // Anzahl Elemente@{PAR} size_t size; // Größe eines Elementes@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion entspricht "malloc", reserviert aber Speicher für einen "anzahl" Elemente großen Vektor des Elementtyps "size". Der Speicherblock wird mit 0 initialisiert.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Funktion liefert NULL falls nicht genügend Speicher reserviert werden konnte. Anderenfalls die Adresse auf den Speicherblock.@{PAR} @{SEE}Siehe auch@{USEE} @{" free " LINK "free"}, @{" malloc " LINK "malloc"}, @{" realloc " LINK "realloc"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} void main(void)@{PAR} {@{PAR} char *str = NULL;@{PAR} if(str = (char *)calloc(10, sizeof(char)))@{PAR} {@{PAR} strcpy(str, "StormC");@{PAR} printf("Speicherblock enthält %s\\n", str);@{PAR} free(str);@{PAR} }@{PAR} else@{PAR} printf("Nicht genung Speicher\\n");@{PAR} }@{PAR} @ENDNODE @NODE ceil "ceil" @{FUNC}ceil@{UFUNC} Aufrunden von Fließkommazahlen@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} d = ceil(x);@{PAR} double d; // Ergebnis@{PAR} double x; // Fließkommazahl@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Analog zu "floor" rundet "ceil" das doppeltgenaue Fließkomma-Argument auf den nächsten ganzahligen größeren Wert.@{PAR} @{RSLT}Rückgabe@{URSLT} Zurückgegeben wird die kleinste Ganzzahl, die größer als das Argument ist als doppeltgenaue Fließkommazahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" floor " LINK "floor"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} double r;@{PAR} void main(void)@{PAR} {@{PAR} r = ceil(473.76); // r enthält den Wert 474.0@{PAR} printf("ceil(473.76) = %lf\\n", r);@{PAR} }@{PAR} @ENDNODE @NODE clearerr "clearerr" @{FUNC}clearerr@{UFUNC} Löscht die Dateiende- und Fehlervermerke einer Datei@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} void clearerr(fp);@{PAR} FILE *fp; // Filepointer@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "clearerr" löscht die Dateiende- und Fehlervermerke einer Datei, so daß anschließend "feof" und "ferror" jeweils 0 ergeben.@{PAR} @{SEE}Siehe auch@{USEE} @{" feof " LINK "feof"}, @{" ferror " LINK "ferror"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} void main(void)@{PAR} {@{PAR} FILE *fp;@{PAR} char ch;@{PAR} fp = fopen("DUMMY.DATEI","w"); // Datei zum Schreiben@{PAR} ch = fgetc(fp); // Versuch von der Datei zu lesen@{PAR} printf("%c\n, ch);@{PAR} if(ferror(fp))@{PAR} {@{PAR} printf("Fehler beim Lesen von "DUMMY.DATEI"\\n");@{PAR} clearerr(fp); // Fehler und EOF - Reset@{PAR} }@{PAR} fclose(fp);@{PAR} }@{PAR} @ENDNODE @NODE clock "clock" @{FUNC}clock@{UFUNC} Liefert die vom Programm beanspruchte Prozessorzeit@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} x = clock(void);@{PAR} clock_t x;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "clock" liefert die Programmlaufzeit, die seit dem Programmstart vergangen ist. Leider ist es nur mit hohem Aufwand möglich, die korrekte CPU-Zeit des Programmes zu berechnen, da hierzu jeder Task-Switch protokolliert werden müßte. Geliefert wird lediglich die seit dem Programmstart vergangene Zeit.@{PAR} Das Ergebnis läßt sich in Sekunden umrechnen, indem durch "CLOCKS_PER_SEC" dividiert wird.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Zeit seit dem Starten des Programmes.@{PAR} @{SEE}Siehe auch@{USEE} @{" system " LINK "system"}, @{" time " LINK "time"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} #include @{PAR} void main(void)@{PAR} {@{PAR} clock_t start, end;@{PAR} double index;@{PAR} start = clock();@{PAR} for(index = 1.0; index <= 1000.0; ++index)@{PAR} (void) log(index);@{PAR} end = clock();@{PAR} // Berechnen der Differenz zwischen beiden Zeiten@{PAR} printf("Differenz %d\\n",(end-start) / CLOCKS_PER_SEC);@{PAR} }@{PAR} @ENDNODE @NODE cos "cos" @{FUNC}cos@{UFUNC} Der Cosinus@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = cos(x)@{PAR} double r; // Ergebnis@{PAR} double x; // Winkel@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion berechnet den Cosinus des Arguments.@{PAR} @{ATT}Hinweis@{UATT} Bei den trigonometrichen Funktionen werden Winkel natürlich im Bogenmaß (Radian) angegeben. Ein Gradwinkel "w" läßt sich mit der Formel@{PAR} x = PI/180.0 * w@{PAR} in Bogenmaß umrechnen.@{PAR} @{SEE}Siehe auch@{USEE} @{" cosh " LINK "cosh"}, @{" sin " LINK "sin"}@{PAR} @ENDNODE @NODE cosh "cosh" @{FUNC}cosh@{UFUNC} Der Cosinus Hyperbolicus@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = cosh(x);@{PAR} double r; // Ergebnis@{PAR} double x; // Winkel@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion berechnet den Cosinus Hyperbolicus des Arguments.@{PAR} @{ATT}Hinweis@{UATT} Bei den trigonometrichen Funktionen werden Winkel natürlich im Bogenmaß (Radian) angegeben. Ein Gradwinkel "w" läßt sich mit der Formel:@{PAR} x = 3.14159265358979/180.0 * w@{PAR} in Bogenmaß umrechnen.@{PAR} @{SEE}Siehe auch@{USEE} @{" exp " LINK "exp"}@{PAR} @ENDNODE @NODE ctime "ctime" @{FUNC}ctime@{UFUNC} Konvertiert einen Zeit-Wert in einen ASCII-Text@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} s = ctime(t);@{PAR} char *s; // Adresse des ASCII-Textes@{PAR} const time_t *t;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "ctime" ist identisch mit "asctime(localtime(t))", wandelt also einen "time_t"-Wert in eine Stringdarstellung um.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Funktion liefert einen ASCII-Text mit der exakten Länge von 26 Zeichen. Das Format des Textes ist:@{PAR} "DDD MMM dd hh:mm:ss YYYY\n\0"@{PAR} DDD ist der Wochentag, MMM ist der Monat, dd ist der Tag im Monat, hh:mm:ss sind Stunde:Minute:Sekunde und YYYY ist das Jahr. Zum Beispiel:@{PAR} "Wed Okt 25 12:05:43 1995\n\0"@{PAR} Der für den String reservierte Speicherbereich wird für die Funktionen "ctime" und "asctime" gleichermaßen verwendet.@{PAR} @{SEE}Siehe auch@{USEE} @{" asctime " LINK "asctime"}, @{" gmtime " LINK "gmtime"}, @{" localtime " LINK "localtime"}, @{" strftime " LINK "strftime"}, @{" time " LINK "time"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} void main(void)@{PAR} {@{PAR} time_t t;@{PAR} time(&t);@{PAR} printf("Die aktuelle Zeit ist %s", ctime(&t));@{PAR} }@{PAR} @ENDNODE @NODE difftime "difftime" @{FUNC}difftime@{UFUNC} Berechnent die Differenz zwischen zwei time_t-Werten@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = difftime(t1, t2);@{PAR} double r; // Ergebnis@{PAR} time_t t1, t2; // Zeiten der Funktion time()@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "difftime" subtrahiert die Zeiten "t1-t2" und liefert das Ergebnis als doppeltgenaue Fließkommazahl in Sekunden.@{PAR} @{RSLT}Rückgabe@{URSLT} Liefert die Differenz zweier Zeiten des Typs time_t in Sekunden.@{PAR} @{SEE}Siehe auch@{USEE} @{" asctime " LINK "asctime"}, @{" ctime " LINK "ctime"}, @{" gmtime " LINK "gmtime"}, @{" localtime " LINK "localtime"}, @{" time " LINK "time"}@{PAR} @ENDNODE @NODE div "div" @{FUNC}div@{UFUNC} Ermittelt den Quotient und den Restwert zweier Ganzzahlen@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} x = div(nenner, zaehler)@{PAR} div_t x; // Quotient und Restwert@{PAR} int nenner; // Nenner@{PAR} int zaehler; // Zaehler@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Da bei den üblichen Divisionsalgorithmen gleichzeitig Quotient und Rest ermittelt werden, ist es natürlich Zeitverschwendung, diese beiden Werte in zwei getrennten Rechenschritten zu berechnen. Der Datentyp "div_t" ist eine Struktur mit den Einträgen "quot" für den Quotienten und "rem" für den Rest.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Funktion "div" liefert eine Struktur des Typs div_t:@{PAR} typedef struct {@{PAR} int rem;@{PAR} int quot;@{PAR} } div_t;@{PAR} @{SEE}Siehe auch@{USEE} @{" ldiv " LINK "ldiv"}@{PAR} @ENDNODE @NODE exit "exit" @{FUNC}exit@{UFUNC} Programm beenden@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} void exit(result)@{PAR} int result; // Return-Code@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion beendet das Programm. Wenn man in einem CLI Befehl einen Returncode an den CLI zurückgeben will, muß das Programm immer mit exit() beendet werden, da der Startupcode das Ergebnis der Mainfunktion ignoriert und immer 0 an das aufrufende Programm zurückgibt.@{PAR} Mit "atexit" eingehängte Funktione werden ausgeführt, Destruktoren für globale Variablen aufgerufen und Ressourcen (mit "fopen" geöffenete Dateien, mit "malloc" oder "calloc" reservierter Speicher usw.) freigegeben.@{PAR} Das Ergebnis 0 zeigt an, daß das Programm erfolgreich ausgeführt wurde, und jeder andere Wert wird als Fehlernummer interpretiert.@{PAR} Speicherbereiche, die mit den Amiga-Funktionen ("AllocMem" etc.) angefordert wurden, oder Dateien, die mit Amiga-Dos-Funktinen ("Open") geöffnet wurden, müssen vor dem Aufruf von "exit" geschlossen werden.@{PAR} @{SEE}Siehe auch@{USEE} @{" abort " LINK "abort"}, @{" atexit " LINK "atexit"}, @{" signal " LINK "signal"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} void main(int argc, char *argv[])@{PAR} {@{PAR} FILE *f;@{PAR} if(argc > 1)@{PAR} {@{PAR} f = fopen(argv[1],"r");@{PAR} if(f == NULL)@{PAR} {@{PAR} fprintf(stderr,@{PAR} "Kann Datei nicht öffnen \"%s\"\n,@{PAR} argv[1]);@{PAR} exit(100);@{PAR} }@{PAR} fclose(f);@{PAR} }@{PAR} @ENDNODE @NODE exp "exp" @{FUNC}exp@{UFUNC} Exponentialfunktion@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = exp(x);@{PAR} double r; // e hoch x@{PAR} double x; // Potenz@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Funktion exp erhebt die Basis e des natürlichen Logarithmus in die Potenz x. Dabei muß x nicht unbedingt ganzzahlig sein.@{PAR} @{RSLT}Rückgabe@{URSLT} Zurückgeliefert wird eine doppeltgenaue Fliekommzahl mit dem berechneten Exponenten.@{PAR} @{SEE}Siehe auch@{USEE} @{" log " LINK "log"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} void main(void)@{PAR} {@{PAR} double result, x = 4.0;@{PAR} result = exp(x);@{PAR} printf("`e' raised to the power of %lf (e ^ %lf) = %lf\n,@{PAR} x, x, result);@{PAR} }@{PAR} @ENDNODE @NODE fabs "fabs" @{FUNC}fabs@{UFUNC} Liefert den absoluten Betrag ihres Arguments@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = fabs(x);@{PAR} double r;@{PAR} double x;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "fabs" berechnet den Absolut-Wert ihres Arguments "x". Das Argument kann eine Fließkommazahl (float) oder eine doppeltgenaue Fließkommazahl (double) sein.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Funktion liefert den Absolut-Wert des Arguments als doppeltgenaue Fließkommazahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" abs " LINK "abs"}@{PAR} @ENDNODE @NODE fclose "fclose" @{FUNC}fclose@{UFUNC} Schließen einer geöffneten Datei@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = fclose(FILE *f)@{PAR} int r; // Ergebnis@{PAR} FILE *fp; // File-Pointer@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Eine geöffnete Datei muß auch wieder geschlossen werden. Die Funktion "fclose" schließt eine Datei, die mit "fopen" geöffnet wurde, und gibt die zugehörige "FILE"-Struktur frei. Vorher werden alle Puffer geschrieben (wie bei "fflush") und freigegeben.@{PAR} Die Funktion "fclose" wird automatisch ausgeführt, wenn das Programm mit "exit" beendet wird und noch Dateien geöffnet sind. Es ist allerdings als guter Programmierstil zu bezeichnen, wenn der Programmierer sich um das Schließen seiner Dateien selbst bemüht.@{PAR} @{RSLT}Rückgabe@{URSLT} Das Ergebnis ist Null oder "EOF" bei einem Fehler. Wird "EOF" zurückgeliefert, können weitere Informationen aus der Variablen "errno" gelesen werden.@{PAR} @{SEE}Siehe auch@{USEE} @{" fflush " LINK "fflush"}, @{" fopen " LINK "fopen"}, @{" freopen " LINK "freopen"}@{PAR} @ENDNODE @NODE feof "feof" @{FUNC}feof@{UFUNC} Überprüft ob das Dateiende erreicht ist@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = feof(fp);@{PAR} int r;@{PAR} FILE *fp;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "feof" liefert einen Wert ungleich 0, wenn in der genannten Datei das Dateiende überschritten wurde.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Funktion liefert einen Wert ungleich Null, wenn der Datei-Zeiger auf dem Dateiende steht. Anderenfalls Null.@{PAR} @{SEE}Siehe auch@{USEE} @{" clearerr " LINK "clearerr"}, @{" ferror " LINK "ferror"}, @{" perror " LINK "perror"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} void main(void)@{PAR} {@{PAR} FILE *stream;@{PAR} stream = fopen("DUMMY.Datei", "r");@{PAR} fgetc(stream); // Ein Zeichen aus der Datei lesen@{PAR} if (feof(stream)) // Dateiende prüfen@{PAR} printf("Das Dateiende wurde erreicht\n");@{PAR} fclose(stream); // Datei schließen@{PAR} }@{PAR} @ENDNODE @NODE ferror "ferror" @{FUNC}ferror@{UFUNC} Fehlervermerk einer Datei prüfen@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = ferror(fp);@{PAR} int r; // Ergebnis@{PAR} FILE *fp; // File-Pointer@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion prüft, ob bei der Datei "fp" bisher ein Fehler aufgetreten ist und vermerkt wurde, und liefert die Fehlernummer oder andernfalls 0.@{PAR} @{RSLT}Rückgabe@{URSLT} Es wird 0 zurückgeliefert, falls bisher kein Fehler aufgetreten ist. Anderenfalls wird ein Wert ungleich Null geliefert.@{PAR} @{SEE}Siehe auch@{USEE} @{" clearerr " LINK "clearerr"}, @{" feof " LINK "feof"}, @{" fopen " LINK "fopen"}, @{" gets " LINK "gets"}, @{" perror " LINK "perror"}@{PAR} @ENDNODE @NODE fflush "fflush" @{FUNC}fflush@{UFUNC} Der Ausgabepuffer wird geschrieben@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = fflush(fp);@{PAR} int r; // Ergebnis@{PAR} FILE *fp; // File-Pointer@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Daten, die sich gerade im Puffer der Datei befinden, werden geschrieben, und der Puffer wird gelöscht. Bei Eingabe-Dateien hat "fflush" keine Wirkung. Wenn als Argument Null gewählt wird, werden alle gerade geöffneten Dateien "geflusht".@{PAR} @{RSLT}Rückgabe@{URSLT} Im Fehlerfall wird -1 ("EOF") geliefert. Die genaue Fehlernummer ist dann in der Variablen "errno" enthalten.@{PAR} @{SEE}Siehe auch@{USEE} @{" fclose " LINK "fclose"}, @{" fopen " LINK "fopen"}, @{" setbuf " LINK "setbuf"}, @{" setvbuf " LINK "setvbuf"}@{PAR} @ENDNODE @NODE fgetc "fgetc" @{FUNC}fgetc@{UFUNC} Liest ein Zeichen aus einer Datei@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} c = fgetc(fp)@{PAR} int c; // gelesenes Zeichen@{PAR} FILE *fp; // File-Pointer@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "fgetc" liest ein Zeichen aus der Datei "fp" und wandelt es zuerst in "unsigned char" und dann in "int" um, denn bekanntlich gibt es in C keine klare Trennung zwischen Zahlen und Zeichen.@{PAR} @{RSLT}Rückgabe@{URSLT} Wenn das Dateiende überschritten wurde oder sonst ein Fehler auftrat, wird "EOF" geliefert.@{PAR} @{SEE}Siehe auch@{USEE} @{" fopen " LINK "fopen"}, @{" fputc " LINK "fputc"}, @{" getc " LINK "getc"}, @{" getchar " LINK "getchar"}, @{" ungetc " LINK "ungetc"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} void main(void)@{PAR} {@{PAR} FILE *fp;@{PAR} char string[] = "Dies ist ein Test", ch;@{PAR} if((fp = fopen("DUMMY.Datei","w+")) == NULL)@{PAR} { printf("Fehler beim Öffnen der Datei\n");@{PAR} exit(0);@{PAR} }@{PAR} // Schreibt den String in die Datei@{PAR} if(fwrite(string, strlen(string), 1, fp) == NULL)@{PAR} { printf("Fehler beim Schreiben in die Datei\n");@{PAR} exit(0);@{PAR} }@{PAR} // Datei-Zeiger auf den Anfang positionieren@{PAR} fseek(fp, 0, SEEK_SET);@{PAR} do@{PAR} {@{PAR} ch = fgetc(fp); // liest ein Zeichen aus der Datei@{PAR} putchar(ch); // Zeichen ausgeben@{PAR} }@{PAR} while(ch != EOF);@{PAR} fclose(fp);@{PAR} }@{PAR} @ENDNODE @NODE fgetpos "fgetpos" @{FUNC}fgetpos@{UFUNC} Liest und speichert die aktuelle Dateiposition@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} x = fgetpos(fp, posn)@{PAR} int x;@{PAR} FILE *fp;@{PAR} fpos_t *posn;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "fgetpos" speichert die aktuelle Position der Datei "fp" in "posn", insbesondere zur späteren Verwendung mit "fsetpos".@{PAR} @{RSLT}Rückgabe@{URSLT} Im Erfolgsfall wird Null zurückgeliefert. Wenn das System selbst nicht so genau weiß, was diese Position ist, liefert "fgetpos" einen Wert ungleich Null. Eine aussagekräftigere Fehlernummer ist dann in "errno" zu finden.@{PAR} @{SEE}Siehe auch@{USEE} @{" fseek " LINK "fseek"}, @{" fsetpos " LINK "fsetpos"}, @{" ftell " LINK "ftell"}@{PAR} @ENDNODE @NODE fgets "fgets" @{FUNC}fgets@{UFUNC} Liest eine Zeile aus einer Datei.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} p = fgets(puffer, len, fp);@{PAR} char *p; // Puffer-Adresse oder NULL@{PAR} char *puffer; // Puffer-Adresse@{PAR} int len; // Pufferlänge in Bytes@{PAR} FILE *fp; // Datei-Adresse@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "fgets" liest eine Zeile mit höchstens "len-1" Zeichen aus "fp" und legt sie einschließlich eines abschließenden Null-Bytes im String-Puffer "puffer" ab. Als Zeilenende gilt entweder ein Linefeed-Zeichen ('\n') oder das Dateiende (EOF). In beiden Fällen wird das jeweilige Zeichen aber nicht in die Stringvariable aufgenommen.@{PAR} @{RSLT}Rückgabe@{URSLT} Wurde das Dateiende bereits überschritten oder trat ein Fehler auf, gibt "fgets" Null, andernfalls die Adresse des Puffers "puffer" zurück. Im Fehlerfall wird zusätzich die Variable "errno" mit einer entsprechenden Fehlernummer versehen.@{PAR} @{SEE}Siehe auch@{USEE} @{" feof " LINK "feof"}, @{" ferror " LINK "ferror"}, @{" fgetc " LINK "fgetc"}, @{" fopen " LINK "fopen"}, @{" fputs " LINK "fputs"}, @{" fread " LINK "fread"}, @{" gets " LINK "gets"}@{PAR} @ENDNODE @NODE floor "floor" @{FUNC}floor@{UFUNC} Abrunden auf die nächstkleinere Ganzzahl@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} x = floor(y);@{PAR} double x, y;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Funktion "floor" rundet auf die nächstkleinere ganze Zahl ab (genaugenommen die größte ganze Zahl kleiner oder gleich "y"). Das Ergebnis ist nichtsdestotrotz ein "double"- und kein "int"-Wert.@{PAR} @{RSLT}Rückgabe@{URSLT} Geliefert wird das abgerundete Ergebnis als doppeltgenaue Fließkommazahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" ceil " LINK "ceil"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} void main(void)@{PAR} {@{PAR} double r;@{PAR} r = floor(147.73); // r enthält 147.0@{PAR} printf("floor(147.73 = %lf\n", r);@{PAR} }@{PAR} @ENDNODE @NODE fmod "fmod" @{FUNC}fmod@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} x = fmod(y, z);@{PAR} double x, y, z;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion sollte nicht mit "modf" verwechselt werden, sie berechnet den Rest, der bei einer Fließkommadivision "y/z" bei ganzzahligem Quotienten auftritt.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Funktion liefert den Wert von "y", wenn "z" gleich Null ist. Anderenfalls wird eine Wert geliefert, der das gleiche Vorzeichen wie "y" hat und kleiner als "z" ist.@{PAR} @{SEE}Siehe auch@{USEE} @{" modf " LINK "modf"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} void main(void)@{PAR} {@{PAR} double r;@{PAR} r = fmod(5.2, 1.5); // r enthält 1.2@{PAR} printf("fmod(5.7, 1.5) = %lf\n", r);@{PAR} } @ENDNODE @NODE fopen "fopen" @{FUNC}fopen@{UFUNC} Erzeugt oder öffnet eine Datei@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} fp = fopen(name, modus);@{PAR} FILE *fp;@{PAR} const char *name;@{PAR} const char *modus;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} öffnet die Datei des angegebenen Namens und mit dem angegebenen Modus, erzeugt dazu eine FILE-Struktur und gibt einen Zeiger darauf zurück. Kann die Datei nicht geöffnet werden, liefert die Funktion Null.@{PAR} Der Modusstring muß einer der folgenden Strings sein: "r": Öffnet eine existierende Datei zum Lesen.@{PAR} "w": Erzeugt eine neue Datei und öffnet sie zum Schreiben.@{PAR} "a": Öffnet eine Datei zum Anhängen ans Dateiende.@{PAR} "r+": Öffnet eine existierende Datei zum Lesen und Schreiben.@{PAR} "w+": Erzeugt eine neue Datei und öffnet sie zum Lesen und Schreiben.@{PAR} "a+": Öffnet eine Datei zum Lesen und Anhängen ans Dateiende.@{PAR} In die Strings kann an 2. oder 3. Stelle noch ein "b" eingefügt werden. Ohne das "b" wird eine Textdatei geöffnet, mit "b" eine Binärdatei. Auf dem Amiga existiert da allerdings kein Unterschied, bei portablen Programmen sollte jedoch der richtige Modus gewählt werden.@{PAR} @ENDNODE @NODE fprintf "fprintf" @{FUNC}fprintf@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = fprintf(f, format, ...)@{PAR} int r;@{PAR} FILE *f;@{PAR} const char *format;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion arbeitet eigentlich genau wie "printf", aber die Daten werden nicht über den Standard-Ausgabestrom, sondern in die Datei "f" ausgegeben. Andersrum formuliert, ist "printf(irgendwas)" eine Abkürzung für "fprintf(stdout, irgendwas)".@{PAR} @ENDNODE @NODE fputc "fputc" @{FUNC}fputc@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = fputc(c,f)@{PAR} int r;@{PAR} int c;@{PAR} FILE *f;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "fputc" schreibt ein Zeichen "c" in eine Datei "f".@{PAR} @{RSLT}Rückgabe@{URSLT} Das Ergebnis ist "EOF" wenn ein Fehler auftritt, andernfalls das ausgegebene Zeichen.@{PAR} @ENDNODE @NODE fputs "fputs" @{FUNC}fputs@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = fputs(s, f)@{PAR} int r; const char *s;@{PAR} FILE *f;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion schreibt eine Zeichenfolge, die wie üblich mit einen Null-Zeichen enden muß in die Datei "f". Das Null-Zeichen wird nicht geschrieben, stattdessen aber ein Zeilenvorschub "\n".@{PAR} @ENDNODE @NODE fread "fread" @{FUNC}fread@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = fread(ptr,size,n,f);@{PAR} unsigned int r;@{PAR} void *ptr;@{PAR} unsigned int size;@{PAR} unsigned int n;@{PAR} FILE *f;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "fread" liest aus der Datei "f" in den Vektor "ptr" maximal "n" Objekte der Größe "size".@{PAR} @{RSLT}Rückgabe@{URSLT} "fread" liefert als Ergebnis die Anzahl der gelesenen Objekte, die durchaus kleiner als "n" sein kann (z.B. wenn das Dateiende erreicht wurde).@{PAR} @ENDNODE @NODE free "free" @{FUNC}free@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} (void) free(ptr);@{PAR} void *ptr;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "free" gibt einen mit "malloc", "calloc" oder "realloc" reservierten Speicherbereich wieder frei.@{PAR} Beim normalen Ende des Programms wird der gesamte bisher nicht freigegebene Speicher noch freigegeben.@{PAR} @ENDNODE @NODE freopen "freopen" @{FUNC}freopen@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} fp = freopen(name, modus, file);@{PAR} FILE *fp;@{PAR} const char *name;@{PAR} const char *modus;@{PAR} FILE *f;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion dient zur Umleitung eines geöffneten Datenstroms. Dazu wird die Datei, die sich hinter dem Pointer "f" verbirgt, geschlossen und eine neue Datei geöffnet und in die Struktur "FILE" auf die "f" zeigt eingehängt.@{PAR} Verwenden sie diese Funktion nicht um die Standardausgabedateien stdin und stdout umzuleiten, da das Schließen dieser Dateien nicht erlaubt ist und durch freopen inplizit geschähe.@{PAR} @{RSLT}Rückgabe@{URSLT} Im Fehlerfall NULL, ansonsten der Parameter "f", der dann auf die neue Datei zeigt.@{PAR} @ENDNODE @NODE frexp "frexp" @{FUNC}frexp@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = frexp(x,expo);@{PAR} double r;@{PAR} double x;@{PAR} int *expo;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} frexp spaltet die Gleitkommazahl "x" in Mantisse und Exponent auf. Der Exponent wird in der Variablen, auf die der Parameter "expo" zeigt abgelegt und wird in der Basis 2 angegeben.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Mantisse als doppelt genaue Fließkommazahl.@{PAR} @ENDNODE @NODE fscanf "fscanf" @{FUNC}fscanf@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = fscanf(f,format, ...);@{PAR} int r;@{PAR} FILE *f;@{PAR} const char *format;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion liest eine formatierte Eingabe aus der Datei "f". Der @{ "Eingabe-Format-String" LINK "EingabeFormatString"} bescheibt das Format der akzeptierbaren Eingaben. Dem Formatstring folgen die Pointer auf die Formatvariablen.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Anzahl der akzeptierten Formatwerte. Paßt die Eingabe nicht zum Formatstring, so ist diese Anzahl kleiner als die Anzahl der Formatvariablen.@{PAR} @ENDNODE @NODE fseek "fseek" @{FUNC}fseek@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = fseek(f,offset,modus);@{PAR} int r;@{PAR} FILE *f;@{PAR} long offset;@{PAR} int modus;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Der Schreib- und Lesezeiger der Datei "f" wird an eine neue Position gesetzt. Der Parameter "offset" gibt die Position relativ zur Startposition, die sich aus dem Modus ergibt an.@{PAR} Als Moduswerte sind erlaubt:@{PAR} SEEK_CUR: Der Offset wird von der aktuellen Position gezählt und kann daher positiv oder negativ sein.@{PAR} SEEK_SET: Der Offset wird vom Anfang der Datei gezählt und sollte positiv sein.@{PAR} SEEK_END: Der Offset wird vom Ende der Datei gezählt und sollte negativ sein.@{PAR} @{RSLT}Rückgabe@{URSLT} Im Fehlerfall wird 0 zurückgegeben, ansonsten ein Wert ungleich 0.@{PAR} @ENDNODE @NODE fsetpos "fsetpos" @{FUNC}fsetpos@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = fsetpos(f,posn);@{PAR} int r;@{PAR} FILE *f;@{PAR} const fpos_t *posn;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Datei "f" wird wieder auf die Position gesetzt, die in "posn" durch den Aufruf der Funktion "fgetpos" abgelegt wurde.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 im Normalfall, ein Wert ungleich 0 im Fehlerfall.@{PAR} @ENDNODE @NODE ftell "ftell" @{FUNC}ftell@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = ftell(f);@{PAR} long r;@{PAR} FILE *f;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert die aktuelle Position des Schreib- und Lesezeigers der Datei "f". Diese Position wird immer relativ zum Dateianfang angegeben.@{PAR} @{RSLT}Rückgabe@{URSLT} Die aktuelle Dateiposition.@{PAR} @ENDNODE @NODE fwrite "fwrite" @{FUNC}fwrite@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = fwrite(ptr,size,n,f);@{PAR} unsigned int r;@{PAR} const void *ptr;@{PAR} unsigned int size;@{PAR} unsigned int n;@{PAR} FILE *f;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Schreibt "n" Objekte der Größe "size" aus dem Vektor "ptr" in die Datei "f".@{PAR} @{RSLT}Rückgabe@{URSLT} Resultat ist die Anzahl der geschriebenen Objekte, die im Falle eines Fehlers kleiner als "n" ist.@{PAR} @ENDNODE @NODE getc "getc" @{FUNC}getc@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} ch = getc(f);@{PAR} int ch;@{PAR} FILE *f;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liest aus der Datei "f" das nächste Zeichen.@{PAR} @{RSLT}Rückgabe@{URSLT} Das nächste Zeichen der Datei oder "EOF" falls das Ende der Datei erreicht ist oder ein Fehler auftrat.@{PAR} @ENDNODE @NODE getchar "getchar" @{FUNC}getchar@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} ch = getchar();@{PAR} int ch; @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liest das nächste Zeichen von der Standardeingabe, ist also identisch mit dem Aufruf getc(stdin).@{PAR} @{RSLT}Rückgabe@{URSLT} Das nächste Zeichen der Standardeingabe oder "EOF" falls das Ende der Datei erreicht ist oder ein Fehler auftrat.@{PAR} @ENDNODE @NODE getenv "getenv" @{FUNC}getenv@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} var = getenv(name);@{PAR} char *var;@{PAR} const char *name;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Funktion liefert den Wert der Umgebungsariablen "name" und liefert einen Zeiger darauf oder Null, wenn keine derartige Variable existiert.@{PAR} Umgebungsvariablen können mit dem CLI Befehl "setenv" oder "set" gesetzt werden.@{PAR} @ENDNODE @NODE gets "gets" @{FUNC}gets@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = gets(s);@{PAR} char *r;@{PAR} char *s;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liest eine Zeile von der Standardeingabe. Die eingelesenen Zeichen werden im String "s" abgelegt. Der abschließende Zeilenvorschub "\n" wird nicht in den String aufgenommen.@{PAR} Dieser String muß den maximal längsten String aus der Standardeingabe aufnehmen können, da dieser von Natur nicht beschränkt ist, nimmt sich StormC die Freiheit, maximal 120 Zeichen einzulesen. Reicht diese Länge nicht, sollte die Funktion fgets verwendet werden.@{PAR} entspricht "fgets(s, STREAM_MAXSTRING, stdin)", liest also eine Zeile von der Standardeingabe.@{PAR} @{RSLT}Rückgabe@{URSLT} Im Fehlerfall NULL, ansonsten der Parameter "s". @ENDNODE @NODE gmtime "gmtime" @{FUNC}gmtime@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} t = gmtime (tp);@{PAR} struct tm *t;@{PAR} const time_t tp;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Zeitangabe "tp" wird in eine ausführliche Zeit- und Datumsstruktur umgesetzt. Diese Zeitstruktur wird auch noch von anderen Zeitfunktionen benutzt und sollte deshalb direkt nach dem Aufruf ausgewertet werden.@{PAR} @{RSLT}Rückgabe@{URSLT} Pointer auf eine Zeitstruktur.@{PAR} @ENDNODE @NODE isalnum "isalnum" @{FUNC}isalnum@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} b = isalnum(ch);@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion testet, ob das übergebene Zeichen ein Buchstabe oder eine Ziffer ist. Aus Portabilitätsgründen wird nur der ASCII Zeichensatz berücksichtigt, es werden also nur "normale" Buchstaben und keine Umlaute o.ä. akzeptiert.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 wenn das Zeichen kein Buchstabe und keine Ziffer ist, sonst ein Wert ungleich 0@{PAR} @{SEE}Siehe auch@{USEE} @ENDNODE @NODE isalpha "isalpha" @{FUNC}isalpha@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} b = isalpha(ch);@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion testet, ob das übergebene Zeichen ein Buchstabe ist. Aus Portabilitätsgründen wird nur der ASCII Zeichensatz berücksichtigt, es werden also nur "normale" Buchstaben und keine Umlaute o.ä. akzeptiert.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 wenn das Zeichen kein Buchstabe ist, sonst ein Wert ungleich 0.@{PAR} @{SEE}Siehe auch@{USEE} @ENDNODE @NODE iscntrl "iscntrl" @{FUNC}iscntrl@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} b = iscntrl(ch);@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion testet, ob das übergebene Zeichen ein Steuercode ist. Unter AmigaOS zählen dazu alle Zeichen, deren ASCII Wert kleiner 32 oder größer 128 und gleichzeitig kleiner 160 ist.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 wenn das Zeichen kein Steuercode ist, sonst ein Wert ungleich 0.@{PAR} @{SEE}Siehe auch@{USEE} @ENDNODE @NODE isdigit "isdigit" @{FUNC}isdigit@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} b = isdigit(ch);@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion testet, ob das übergebene Zeichen eine Ziffer ist, also ein Zeichen zwischen '0' und '9'.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 wenn das Zeichen keine Ziffer ist, sonst ein Wert ungleich 0.@{PAR} @{SEE}Siehe auch@{USEE} @ENDNODE @NODE isgraph "isgraph" @{FUNC}isgraph@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} b = isgraph(ch);@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion testet, ob das übergebene Zeichen ein sichtbares Zeichen ist. Dazu zählen alle Zeichen, die auf dem Bildschirm etwas darstellen, das Leerzeichen zählt deshalb nicht dazu.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 wenn das Zeichen kein sichtbares Zeichen ist, sonst ein Wert ungleich 0.@{PAR} @{SEE}Siehe auch@{USEE} @ENDNODE @NODE islower "islower" @{FUNC}islower@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} b = islower(ch);@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion testet, ob das übergebene Zeichen ein Kleinbuchstabe ist. Aus Portabilitätsgründen zählen nur die Zeichen 'a' bis 'z' zu den Kleinbuchstaben, Umlaute werden nicht berücksichtigt.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 wenn das Zeichen kein Kleinbuchstabe ist, sonst ein Wert ungleich 0.@{PAR} @{SEE}Siehe auch@{USEE} @ENDNODE @NODE isprint "isprint" @{FUNC}isprint@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} b = isprint(ch);@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion testet, ob das übergebene Zeichen ein druckbares Zeichen ist. Dazu zählen alle Zeichen mit den ASCII Werten 32 bis 127 und 160 bis 255.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 wenn das Zeichen kein druckbares Zeichen ist, sonst ein Wert ungleich 0.@{PAR} @{SEE}Siehe auch@{USEE} @ENDNODE @NODE ispunct "ispunct" @{FUNC}ispunct@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} b = ispunct(ch);@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion testet, ob das übergebene Zeichen ein Sonderzeichen ist. Dazu zählen alle Zeichen mit den ASCII Werten 32 bis 127 und 160 bis 255, die kein Buchstabe und keine Ziffer sind. Aus Portabilitätsgründen werden Umlaute zu den Sonderzeichen gezählt.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 wenn das Zeichen kein Sonderzeichen ist, sonst ein Wert ungleich 0.@{PAR} @{SEE}Siehe auch@{USEE} @ENDNODE @NODE isspace "isspace" @{FUNC}isspace@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} b = isspace(ch);@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion testet, ob das übergebene Zeichen ein Leerraum ist. Neben dem eigentlichen Leerzeichen zählen dazu auch alle Tabulatoren '\t', Zeilenvorschübe '\n', Wagenrückläufe '\r', Seitenvorschübe '\f' und Vertikaltabulatoren '\v'.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 wenn das Zeichen kein Leerraum ist, sonst ein Wert ungleich 0.@{PAR} @{SEE}Siehe auch@{USEE} @ENDNODE @NODE isupper "isupper" @{FUNC}isupper@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} b = isupper(ch);@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion testet, ob das übergebene Zeichen ein Großbuchstabe ist. Aus Portabilitätsgründen werden Umlaute nicht zu den Buchstaben gezählt.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 wenn das Zeichen kein Großbuchstabe ist, sonst ein Wert ungleich 0.@{PAR} @{SEE}Siehe auch@{USEE} @ENDNODE @NODE isxdigit "isxdigit" @{FUNC}isxdigit@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} b = isxdigit(ch);@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion testet, ob das übergebene Zeichen eine Hexadezimalziffer ist. Dazu zählen die dezimalen Ziffern '0' bis '9', die Kleinbuchstaben 'a' bis 'f' und die Großbuchstaben 'A' bis 'F'. @{RSLT}Rückgabe@{URSLT} 0 wenn das Zeichen keine Hexadezimalziffer ist, sonst ein Wert ungleich 0.@{PAR} @{SEE}Siehe auch@{USEE} @ENDNODE @NODE labs "labs" @{FUNC}labs@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = labs(l);@{PAR} long int r;@{PAR} long int l;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert den absoluten Wert der Zahl "l". Diese Funktion kann auch als Makro definiert werden, etwa:@{PAR} #define labs(l) ((l) < 0 ? -(l) : (l)) Allerdings wird hierbei "l" dreimal ausgewertet und sollte deshalb nie als komplexer Ausdruck (etwa noch mit Seiteneffekten) angegeben werden. Im allgemeinen ist deshalb die Fnktion labs vorzuziehen.@{PAR} @{RSLT}Rückgabe@{URSLT} Der absolute Betrag.@{PAR} @{SEE}Siehe auch@{USEE} @{" abs " LINK "abs"}, @{" fabs " LINK "fabs"}@{PAR} @ENDNODE @NODE ldexp "ldexp" @{FUNC}ldexp@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} d = ldexp(x,exponent);@{PAR} double x;@{PAR} int exponent;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion multipliziert die Zahl "x" mit der ganzzahligen Potenz "n" von 2.@{PAR} @{RSLT}Rückgabe@{URSLT} Das Produkt x * (2 hoch exponent) als doppelt genaue Gleitkommazahl.@{PAR} @ENDNODE @NODE ldiv "ldiv" @{FUNC}ldiv@{UFUNC} @{SYN}Übersicht@{USYN} #include r = ldiv(dividend,divisor);@{PAR} long dividend;@{PAR} long divisor;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion teilt den Dividenden "dividend" durch den Divisor "divisor" und liefert gleichzeitig Quotient und Rest in einer Struktur ldiv_t.@{PAR} @{RSLT}Rückgabe@{URSLT} Quotient und Rest der ganzzahligen Division.@{PAR} @{SEE}Siehe auch@{USEE} @{" div " LINK "div"}@{PAR} @ENDNODE @NODE localtime "localtime" @{FUNC}localtime@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} t = localtime(tp);@{PAR} struct tm *t;@{PAR} const time_t *tp;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion setzt den übergebenen Zeitwert in eine Zeit- und Datumsstruktur um. Der Zeitwert auf den "tp" zeigt wird dabei in lokaler Zeit interpretiert.@{PAR} Das Ergebnis wird in einer globalen Struktur zurückgegeben, die auch noch durch andere Zeitfunktionen benutzt wird und sollte deshalb unmittelbar nach dem Aufruf ausgewertet werden.@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf die ausgefüllte Zeit- und Datumsstruktur.@{PAR} @{SEE}Siehe auch@{USEE} @{" gmtime " LINK "gmtime"}@{PAR} @ENDNODE @NODE log "log" @{FUNC}log@{UFUNC} Der natürliche Logarithmus@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = log(x);@{PAR} double r;@{PAR} double x;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Berechnet den natürlichen Logarithmus einer Gleitkommazahl doppelter Genauigkeit. Der natürliche Logarithmus wird zur Basis e gebildet und ist die Umkehrfunktion der Exponentialfunktion exp.@{PAR} @{RSLT}Rückgabe@{URSLT} Der natürliche Logarithmus als doppelt genaue Gleitkommzahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" exp " LINK "exp"}, @{" log10 " LINK "log10"}@{PAR} @ENDNODE @NODE log10 "log10" @{FUNC}log10@{UFUNC} Der dekadische Logarithmus@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = log10(x);@{PAR} double r;@{PAR} double x;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Berechnet den Logarithmus zur Basis 10 einer doppelt genauen Gleitkommazahl und ist die Umkehrfunktion zur Potenzierungsfunktion der Potenz 10.@{PAR} @{RSLT}Rückgabe@{URSLT} Der dekadische Logarithmus als doppelt genaue Gleitkommazahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" pow " LINK "pow"}, @{" log " LINK "log"}@{PAR} @ENDNODE @NODE longjmp "longjmp" @{FUNC}longjmp@{UFUNC} Weiter Sprung@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} (void) longjmp(buffer,result);@{PAR} jmp_buf buffer;@{PAR} int result;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Springt an die Position die durch setjmp in dem "buffer" abgelegt wurde. Dabei kann man auch über Funktionsgrenzen weg springen in andere Funktionen zurück. Der zweite Parameter "result" wird von dem zugehörigen setjmp als Ergebnis zurückgegeben.@{PAR} @{SEE}Siehe auch@{USEE} @{" setjmp " LINK "setjmp"}@{PAR} @ENDNODE @NODE malloc "malloc" @{FUNC}malloc@{UFUNC} dynamischen Speicher reservieren@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} (void) malloc(size);@{PAR} size_t size;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} "malloc" reserviert "size" Bytes Speicher und gibt einen Zeiger darauf zurück. Dieser Speicher wird bei StormC zuerst gelöscht (d.h. mit 0 gefüllt). Auf dieses Verhalten sollte man sich bei Programmen die portierbar sein sollen allerdings nicht verlassen.@{PAR} Wird der Speicher nicht mehr länger benötigt, sollte er mit free wieder freigegeben werden. Nicht freigegebener Speicher wird bei normalen Programmende automatisch freigegeben.@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf den Speicher oder NULL falls kein Speicher frei ist.@{PAR} @{SEE}Siehe auch@{USEE} @{" calloc " LINK "calloc"}, @{" realloc " LINK "realloc"}, @{" free " LINK "free"}@{PAR} @ENDNODE @NODE memchr "memchr" @{FUNC}memchr@{UFUNC} Zeichensuche im Speicher@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} pos = memchr(start,ch,size);@{PAR} void *pos;@{PAR} const void *start;@{PAR} int ch;@{PAR} size_t size;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Sucht das erste Vorkommen des Zeichens "ch" in dem Speicherbereich, der ab "start" beginnt und "size" Bytes lang ist.@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf das Zeichen im Speicherbereich oder NULL, falls das Zeichen nicht in dem Speicherbereich vorkommt.@{PAR} @ENDNODE @NODE memcmp "memcmp" @{FUNC}memcmp@{UFUNC} Speichervergleich@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = memcmp(mem1,mem2,n);@{PAR} int r;@{PAR} const void *mem1;@{PAR} const void *mem2;@{PAR} size_t n;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Vergleicht die beiden Speicherbereiche "mem1" und "mem2" auf maximal "n" Bytes Länge. Wie bei Vergleichen üblich wird ein Wert größer 0 zurückgegeben, wenn das erste unterschiedliche Zeichen im Speicherbereich "mem1" größer ist als das entsprechende Zeichen im Speicherbereich "mem2". Es wird ein Wert kleiner 0 zurückgegeben, wenn das erste unterschiedliche Zeichen in "mem1" kleiner ist als das entsprechende in "mem2". Und es wird 0 zurückgegeben, wenn alle Zeichen der beiden Speicherbereiche identisch sind.@{PAR} @{RSLT}Rückgabe@{URSLT} 0, wenn beide Speicherbereiche gleich sind.@{PAR} >0, wenn "mem1" größer als "mem2" ist.@{PAR} <0, wenn "mem1" kleiner als "mem2" ist.@{PAR} @{SEE}Siehe auch@{USEE} @{" strcmp " LINK "strcmp"}, @{" strncmp " LINK "strncmp"}@{PAR} @ENDNODE @NODE memcpy "memcpy" @{FUNC}memcpy@{UFUNC} Speicher kopieren@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = memcpy(dest,source,n);@{PAR} void *r;@{PAR} void *dest;@{PAR} const void *source;@{PAR} size_t n;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Von dem Speicherbereich "source" werden "n" Bytes in den Speicherbereich "dest" kopiert. Die beiden Speicherbereiche der Länge "n" dürfen sich nicht überlappen. @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf den Zielbereich.@{PAR} @{SEE}Siehe auch@{USEE} @{" memmove " LINK "memmove"}@{PAR} @ENDNODE @NODE memmove "memmove" @{FUNC}memmove@{UFUNC} Speicher kopieren@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = memmove(dest,source,n);@{PAR} void *r;@{PAR} void *dest;@{PAR} const void *source;@{PAR}; size_t n;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Von dem Speicherbereich "source" werden "n" Bytes in den Speicherbereich "dest" kopiert. Die beiden Speicherbereiche der Länge "n" dürfen sich überlappen. @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf den Zielbereich.@{PAR} @{SEE}Siehe auch@{USEE} @{" memcpy " LINK "memcpy"}@{PAR} @ENDNODE @NODE memset "memset" @{FUNC}memset@{UFUNC} Speicherbereich füllen@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = memset(dest,ch,n);@{PAR} void *r;@{PAR} void *dest;@{PAR} int ch;@{PAR} size_t n;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Schreibt das Zeichen "ch" in den Speicherbereich "dest" der Länge "n". Das Zeichen "ch" wird als Byte in den Speicher geschrieben, nicht als Langwort, wie der Typ int vermuten läßt. @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf den gefüllten Speicherbereich.@{PAR} @ENDNODE @NODE mktime "mktime" @{FUNC}mktime@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} timevalue = mktime(tp);@{PAR} time_t timevalue;@{PAR} struct tm *tp;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Berrechnet aus der vollständig initialisierten Zeit- und Datumsstruktur "tp" einen komprimierten Zeitwert.@{PAR} StormC begnügt sich mit der normalen Zeit- und Datumsangabe zur Berrechnung des Zeitwertes, die exotischeren Strukturfelder wie "Tag im Jahr" oder "Woche im Jahr" müssen nicht initialisiert sein. Dieses Verhalten darf bei portablen Programmen allerdings nicht erwartet werden.@{PAR} @{RSLT}Rückgabe@{URSLT} Der komprimierte Zeitwert.@{PAR} @{SEE}Siehe auch@{USEE} @{" localtime " LINK "localtime"}, @{" time " LINK "time"}@{PAR} @ENDNODE @NODE modf "modf" @{FUNC}modf@{UFUNC} Vor- und Nachkommateil einer Gleitkommazahl.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} nachkommateil = modf(x,vorkommateil);@{PAR} double nachkommateil;@{PAR} double x;@{PAR} double *vorkommateil;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Gleitkommazahl "x" wird in ihren Vor- und Nachkommateil aufgespalten. Der Nachkommateil ist eine Zahl zwischen -1 und +1 (ohne diese beiden Wert je anzunehmen). Der Vorkommateil wird in der Variablen abgelegt, auf die der Zeiger "vorkommateil" zeigt.@{PAR} @{RSLT}Rückgabe@{URSLT} Der Nachkommateil als doppelt genaue Gleitkommazahl.@{PAR} @ENDNODE @NODE offsetof "offsetof" @{FUNC}offsetof@{UFUNC} Offset eines Strukturelements@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} #define offsetof(s,m) ((unsigned)&((s*)NULL)->m)@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Ein Makro, daß den Offset eines Struktureintrags liefert. Der Parameter "s" muß der Typname einer Struktur sein, "m" ein Element dieser Struktur.@{PAR} @{RSLT}Rückgabe@{URSLT} Der Offset des Strukturelements als unsigned int.@{PAR} @ENDNODE @NODE perror "perror" @{FUNC}perror@{UFUNC} Ausgabe einer Fehlermeldung@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} (void) perror(msgheader);@{PAR} const char *msgheader;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Gibt eine Fehlermeldung aus, die sich aus dem "msgheader" und einem Text, der sich aus dem Wert der Fehlervariable errno ergibt zusammensetzt. @ENDNODE @NODE printf "printf" @{FUNC}printf@{UFUNC} @{SYN}Übersicht@{USYN} #include @{PAR} r = printf(formatstring, ...);@{PAR} int r;@{PAR} const char *formatstring;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Formatierte Ausgabe auf der Standardausgabe stdout. Der @{"Ausgabe-Format-String" LINK "AusgabeFormatString"} beschreibt das Format der Ausgabe, danach folgen die Parameter, die für die Ausgabe benötigt werden.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" fprintf " LINK "fprintf"}, @{" vprintf " LINK "vprintf"}@{PAR} @ENDNODE @NODE pow "pow" @{FUNC}pow@{UFUNC} Die Potenzierungsfunktion@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = pow (x,potenz)@{PAR} double r;@{PAR} double x;@{PAR} double exponent;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion berechnet die Potenz "x" hoch "potenz", wobei "x" positiv sein muß.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Potenz "x" hoch "potenz" als doppelt genaue Gleitkommazahl.@{PAR} @ENDNODE @NODE putc "putc" @{FUNC}putc@{UFUNC} Ausgabe eines Zeichens@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = putc(ch,f);@{PAR} int r;@{PAR} int ch;@{PAR} FILE *f;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Das Zeichen "ch" wird in die Datei "f" ausgegeben.@{PAR} @{RSLT}Rückgabe@{URSLT} Im Fehlerfall EOF, sonst das ausgegebene Zeichen.@{PAR} @{SEE}Siehe auch@{USEE} @{" fputc " LINK "fputc"}@{PAR} @ENDNODE @NODE putchar "putchar" @{FUNC}putchar@{UFUNC} Ausgabe eines Zeichens in die Standardausgabe@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = putchar(ch);@{PAR} int r;@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Das Zeichen "ch" wird in die Standardausgabe geschrieben.@{PAR} @{RSLT}Rückgabe@{URSLT} Im Fehlerfall EOF, sonst das augegebene Zeichen.@{PAR} @{SEE}Siehe auch@{USEE} @{" putc " LINK "putc"}, @{" fputc " LINK "fputc"}@{PAR} @ENDNODE @NODE puts "puts" @{FUNC}puts@{UFUNC} Ausgabe eines Strings@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = puts(s);@{PAR} int r;@{PAR} cinst char *s;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Der String "s" wird in die Stadardausgabe geschrieben, das abschließende Nullzeichen wird nicht ausgegeben, statt dessen wird ein Zeilenvorschub "\n" ausgegeben.@{PAR} @{RSLT}Rückgabe@{URSLT} Im Fehlerfall EOF, sonst ein Wert größer oder gleich 0.@{PAR} @{SEE}Siehe auch@{USEE} @{" fputs " LINK "fputs"}@{PAR} @ENDNODE @NODE qsort "qsort" @{FUNC}qsort@{UFUNC} Schnelles Sortieren eines Vektors.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} (void) qsort(vektor,anzahl,size,compare);@{PAR} void *vektor;@{PAR} size_t anzahl;@{PAR} size_t size;@{PAR} int (*compare)(const void *, const void *);@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion sortiert den Vektor "vektor". Dieser Vektor muß "anzahl" Einträge haben, die jeweils eine Größe von "size" Bytes besitzen. Die Elemente werden bei Bedarf durch byteweises Kopieren vertauscht.@{PAR} Die Vergleichsfunktion "compare" erhält zwei Elemente des Vektors und muß einen Wert größer 0 zurückgeben, wenn das 1. Element größer als das zweite ist, eine Wert gleich 0, wenn beide Elemente gleich sind und einen Wert kleiner 0, wenn das 1. Element kleiner als das zweite ist.@{PAR} Besonders schnell ist das Sortieren natürlich, wenn für größere Objekte im Vektor Zeiger auf die Objekte stehen (z.B. Zeiger auf Strings) und nicht die Objekte direkt.@{PAR} @{SEE}Siehe auch@{USEE} @{" strcmp " LINK "strcmp"}@{PAR} @ENDNODE @NODE raise "raise" @{FUNC}raise@{UFUNC} Auslösen eines Signals@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = raise(signalnumber);@{PAR} int r;@{PAR} int signalnumber;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Das Sinal "signalnumber" wird ausgelöst. Dazu wird eine Funktion, die vorher mit signal gesetzt wurde aufgerufen.@{PAR} Als Signalnummern sind erlaubt:@{PAR} SIGABRT für ein unnormales Programmende, die Funktion abort löst eben dieses Signal aus.@{PAR} SIGFPE für einen Arithmetikfehler.@{PAR} SIGILL für eine illegale Prozessoranweisung.@{PAR} SIGINT für einen Softwareinterrupt.@{PAR} SIGSEGV für einen illegalen Speicherzugriff.@{PAR} SIGTERM für ein normales Programmende.@{PAR} StormC benutzt nur das Signal SIGABRT innerhalb der Funktion abort, die anderen Signale werden nicht verwendet.@{PAR} Diese Funktion darf nicht mit der Amiga Funktion Signal verwechselt werden, die ein echtes Signal im Multitasking an einen anderen Task schickt und asynchron arbeitet. Die Funktion raise ist nichts weiter als der synchrone Aufruf einer Funktion aus einer Funktionstabelle und erlaubt nur bestimmte Software Ausnahmen global zu behandeln.@{PAR} @{SEE}Siehe auch@{USEE} @{" signal " LINK "signal"}@{PAR} @ENDNODE @NODE rand "rand" @{FUNC}rand@{UFUNC} Zufallszahl ermitteln@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} int rand();@{PAR} int number;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert eine Zufallszahl nach einem möglichst undurchschaubarem Algorithmus.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Zufallszahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" srand " LINK "srand"}@{PAR} @ENDNODE @NODE realloc "realloc" @{FUNC}realloc@{UFUNC} Ändern des SPeicherplatzbedarfs eines Objekts@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} newmem = realloc(oldmem,newsize);@{PAR} void *newmem;@{PAR} void *oldmem;@{PAR} size_t newsize;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Es wird neuer Speicherplatz für das Objekt "oldmem" mit "newsize" Bytes reserviert, das alte Objekt wird in das neue kopiert und das alte Objekt freigegeben.@{PAR} Wenn für das neue Objekt kein Speicher reserviert werden konnte, so wird das alte Objekt nichtfreigegeben.@{PAR} Durch das Speicherhandling bei AmigaOS muß immer neuer Speicher reserviert werden, ein teilweises erweitern oder verkleinern eines bestehenden Speicherblocks ist nicht möglich.@{PAR} @{RSLT}Rückgabe@{URSLT} Der Zeiger auf den neuen Speicherbereich oder NULL im Fehlerfall.@{PAR} @{SEE}Siehe auch@{USEE} @{" malloc " LINK "malloc"}, @{" calloc " LINK "calloc"}, @{" free " LINK "free"}@{PAR} @ENDNODE @NODE remove "remove" @{FUNC}remove@{UFUNC} Löschen einer Datei@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} error = remove(filename);@{PAR} int error;@{PAR} const char *filename;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Datei "filename" wird gelöscht. Bei dem Dateinamen handelt es sich um einen üblichen AmigaDOS Dateipfad, der relativ zum aktuellen Verzeichnis des Programms interpretiert wird.@{PAR} @{RSLT}Rückgabe@{URSLT} Im Fehlerfall ein Wert ungleich 0, sonst 0.@{PAR} @ENDNODE @NODE rename "rename" @{FUNC}rename@{UFUNC} Umbenennen einer Datei@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} error = rename(oldname,newname);@{PAR} int error;@{PAR} const char *oldname;@{PAR} const char *newname;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die Datei "oldname" wird umbenannt in "newname". Eine Umbenennung kann nur auf dem gleichen physikalischen Datenträger (Volume) gelingen, ein Verschieben einer Datei in ein anderes Verzeichnis ist dabei allerdings erlaubt.@{PAR} @{RSLT}Rückgabe@{URSLT} Im Fehlerfall ein Wert ungleich 0, sonst 0. @ENDNODE @NODE rewind "rewind" @{FUNC}rewind@{UFUNC} Zurücksetzen einer Datei@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} (void) rewind(f);@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Der Lese-/Schreibzeiger der Datei "f" wird auf den Anfang zurückgesetzt und das Fehlerflag gelöscht.@{PAR} @ENDNODE @NODE scanf "scanf" @{FUNC}scanf@{UFUNC} Einlesen von der Standardeingabe@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = scanf(format, ...);@{PAR} int r; const char *format;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion liest Zeichen von stdin und interpretiert sie nach dem Format des @{"Eingabe-Format-Strings" LINK "EingabeFormatString"}. Zur Speicherung der gelesenen Daten werden weitere Pointer auf Variablen erwartet, die eine nach dem anderen die Daten aufnehmen.@{PAR} Ein Fehler bei der Eingabe (z.B. zum Formatstring unpassende Eingabedaten) erkennt man an einem Rückgabewert, der kleiner als die Anzahl der Formatvariablen ist.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Anzahl der gelesenen Daten.@{PAR} @{SEE}Siehe auch@{USEE} @{" fscanf " LINK "fscanf"}, @{" sscanf " LINK "sscanf"}@{PAR} @ENDNODE @NODE setbuf "setbuf" @{FUNC}setbuf@{UFUNC} Setzen eines Datenpuffers@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} (void) setbuf(f,buf);@{PAR} FILE *f;@{PAR} char *buf;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Setzt einen Datenpuffer "buf" der Größe BUFSIZ für die Datei "f". Normalerweise ist es nicht nötig einer Datei einen Datenpuffer manuell zu setzen, da jede Datei beim Öffnen automatisch einen geeignet großen Datenpuffer erhält.@{PAR} @{SEE}Siehe auch@{USEE} @{" setvbuf " LINK "setvbuf"}@{PAR} @ENDNODE @NODE setjmp "setjmp" @{FUNC}setjmp@{UFUNC} Merken eines Sprungziels für weite Sprünge@{PAR} @{SYN}Übersicht@{USYN} #include r = setjmp(buf)@{PAR} int r;@{PAR} jmp_buf buf;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Diese Funktion setzt ein Sprungziel für weite Sprünge mittels longjmp, indem der Programmzustand in dem Buffer "buf" gespeichert wird. Beim Aufruf der Funktion ist der Rückgabewert immer 0, wird diese Funktion jedoch durch den Aufruf eines longjmp beendet, wird das Ergebnis der Funktion durch den Parameter des longjmp Aufrufs bestimmt.@{PAR} @{RSLT}Rückgabe@{URSLT} 0 oder durch den Aufruf von longjmp festgelegt.@{PAR} @{SEE}Siehe auch@{USEE} @{" longjmp " LINK "longjmp"}@{PAR} @ENDNODE @NODE setvbuf "setvbuf" @{FUNC}setvbuf@{UFUNC} Setzen eines Dateipuffers@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = setvbuf(f,buf,mode,size);@{PAR} int r;@{PAR} FILE *f;@{PAR} char *buf;@{PAR} int mode;@{PAR} unsigned size;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Setzt für die Datei "f" den Dateipuffer "buf" der Länge "size". Der Modus "mode" bezeichnet dabei die Art, wie die Datei gepuffert werden soll:@{PAR} _IOFBF setzt vollständige Pufferung, d.h. erst wenn der Puffer voll ist, wird eine Ausgabe in die physikalische Datei erfolgen.@{PAR} _IOLBF setzt die zeilenweise Pufferung, d.h. sobald eine Zeile mit einem Zeilenvorschub "\n" abgeschlossen ist, wird der Puffer ausgegeben.@{PAR} _IONBF löscht die Pufferung, d.h. jede Ausgabe oder Eingabe erfolgt direkt von der physikalischen Datei.@{PAR @ENDNODE @NODE signal "signal" @{FUNC}signal@{UFUNC} Setzen einer Signalfunktion@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = signal(signalnumber,f);@{PAR} void (*r)(int);@{PAR} int signalnumber;@{PAR} void (*f)(int);@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Setzt eine Funktion "f", die auf das Signal "signalnumber" reagieren soll. Dieses Signal wird durch einen Aufruf von raise ausgelöst, d.h. die Funktion "f" wird dann aufgerufen. Als Parameter erhält die Funktion "f" auch die Signalnummer "signalnumber". Dadurch kann auch eine Funktion auf mehrere Signale reagieren.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Funktion, die vorher auf das Signal reagierte, oder NULL.@{PAR} @{SEE}Siehe auch@{USEE} @{" raise " LINK "raise"}, @{" abort " LINK "abort"}@{PAR} @ENDNODE @NODE sin "sin" @{FUNC}sin@{UFUNC} Der Sinus@{PAR} @{SYN}Übersicht@{USYN} #include@{PAR} r = sin(x);@{PAR} double r;@{PAR} double x;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert den Sinus von "x".@{PAR} Bei den trigonometrichen Funktionen werden Winkel natürlich im Bogenmaß (Radian) angegeben. Ein Gradwinkel "w" läßt sich mit der Formel@{PAR} x = 3.14159265358979/180.0 * w@{PAR} in Bogenmaß umrechnen.@{PAR} @{RSLT}Rückgabe@{URSLT} Der Sinus als doppelt genaue Gleitkommzahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" cos " LINK "cos"}, @{" asin " LINK "asin"}@{PAR} @ENDNODE @NODE sinh "sinh" @{FUNC}sinh@{UFUNC} Der Sinus Hyperbolicus@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = sinh(x);@{PAR} double r;@{PAR} double x;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert den Sinus Hyperbolicus einer doppelt genauen Fließkommazahl.@{PAR} @{RSLT}Rückgabe@{URSLT} Der Sinus Hyperbolicus als doppelt genaue Gleitkommazahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" cosh " LINK "cosh"}@{PAR} @ENDNODE @NODE sprintf "sprintf" @{FUNC}sprintf@{UFUNC} Formatierte Ausgabe auf einen String.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = sprintf(s,format,...)@{PAR} int r;@{PAR} char *s;@{PAR} const char *format;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die formatierte Ausgabe erfolgt nach dem @{"Ausgabe-Format-String" LINK "AusgabeFormatString"} "format" und den zusätzlich angegeben Parametern in den String "s". Dieser String wird immer mit einem Nullzeichen abgeschlossen und der zur Verfügung stehende Speicherplatz des Strings muß so groß sein, daß die längste Ausgabe noch hineinpaßt - dies kann die Funktion nicht überprüfen.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Anzahl der ausgegeben Zeichen.@{PAR} @{SEE}Siehe auch@{USEE} @{" printf " LINK "printf"}, @{" sscanf " LINK "sscanf"}@{PAR} @ENDNODE @NODE sqrt "sqrt" @{FUNC}sqrt@{UFUNC} Die Quadratwurzel@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = sqrt(x);@{PAR} double r;@{PAR} double x;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert die Quadratwurzel der doppelt genauen Gleitkommzahl "x". Der dazu verwendete Algorithmus ist schneller als pow(x,0.5).@{PAR} @{RSLT}Rückgabe@{URSLT} Die Quadratwurzel als doppelt genaue Fließkommazahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" pow " LINK "pow"}@{PAR} @ENDNODE @NODE srand "srand" @{FUNC}srand@{UFUNC} Setzen eines Startwerts für den Zufallsgenerator.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} (void) srand(seed);@{PAR} unsigned int seed;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Der Zufallsgenerator rand ist natürlich ein Algorithmus, der immer die gleiche Folge von Zufallszahlen ausgibt. Mit dieser Funktion kann man für die Folge einen Startwert "seed" festlegen, um diese Folge zu beeinflussen. Dieser Startwert sollte bei jedem Programmlauf neu gesetzt werden, z.B. aus der Uhrzeit des Rechners ermittelt werden.@{PAR} @{SEE}Siehe auch@{USEE} @{" rand " LINK "rand"}, @{" time " LINK "time"}@{PAR} @ENDNODE @NODE sscanf "sscanf" @{FUNC}sscanf@{UFUNC} Formtierte Eingabe aus einem String@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} int sscanf(char *s, const char *format, ...);@{PAR} int r;@{PAR} char *s;@{PAR} const char *format;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Die formatierte Eingabe nach dem @{"Eingabe-Format-String" LINK "EingabeFormatString"} "format" erfolgt aus dem String "s". Die weiteren Parameter sind Pointer auf Variablen, deren Typ und Anzahl durch den Formatstring festgelegt wird.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Anzahl der erfolgten Eingaben.@{PAR} @{SEE}Siehe auch@{USEE} @{" scanf " LINK "scanf"}, @{" fscanf " LINK "fscanf"}, @{" sprintf " LINK "sprintf"}@{PAR} @ENDNODE @NODE strcat "strcat" @{FUNC}strcat@{UFUNC} Anhängen eines Strings@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = strcat (s,t);@{PAR} char *r;@{PAR} char *s;@{PAR} char *t;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Der String "t" wird an den String "s" angehängt. Dabei muß der Speicherbereich des Strings "s" wenigstens so groß sein, wie die Länge von "t" plus die Länge von "s" plus 1 (für das Nullzeichen).@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf den String "s"@{PAR} @ENDNODE @NODE strchr "strchr" @{FUNC}strchr@{UFUNC} Suchen eines Zeichens@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} char *strchr (const char *s, int c)@{PAR} char *r;@{PAR} const char *s;@{PAR} int c;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Sucht das erste Vorkommen des Zeichens "c" in dem String "s".@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf das gefundene Zeichen oder NULL.@{PAR} @ENDNODE @NODE strcmp "strcmp" @{FUNC}strcmp@{UFUNC} Vergleich zweier Strings@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} int strcmp (const char *s1, const char *s2)@{PAR} int r;@{PAR} const char *left;@{PAR} const char *right;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Vergleicht die beiden Strings Zeichen für Zeichen. Falls beide Strings exakt gleich sind, ist der Rückgabewert 0, falls das erste unterschiedliche Zeichen im String "left" kleiner als im String "right" ist, ist der Wert kleiner 0, sonst größer 0. Das Nullzeichen am Stringende gilt als das kleinste Zeichen.@{PAR} @{RSLT}Rückgabe@{URSLT} Der Rückgabewert ist 0, wenn beide Strings gleich sind, kleiner 0, wenn der erste String kleiner als der zweite ist, sonst ein Wert größer 0.@{PAR} @{SEE}Siehe auch@{USEE} @{" strncmp " LINK "strncmp"}, @{" stricmp " LINK "stricmp"}@{PAR} @ENDNODE @NODE strcpy "strcpy" @{FUNC}strcpy@{UFUNC} Kopieren eines Strings@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = strcpy(dest,source); char *r;@{PAR} char *dest;@{PAR} const char *source;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Kopiert den String "source" in den String "dest". Der Speicherbereich des Strings "dest" muß mindestens so groß sein, wie der String "source" lang ist plus 1 für das Nullzeichen am Ende des Strings.@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf den String "dest".@{PAR} @{SEE}Siehe auch@{USEE} @{" strncpy " LINK "strncpy"}@{PAR} @ENDNODE @NODE strcspn "strcspn" @{FUNC}strcspn@{UFUNC} Suchen einer Zeichenmenge in einem String@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} index = strcspn(s,chars);@{PAR} size_t r;@{PAR} const char *s;@{PAR} const char *chars;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Ermittelt den Index des ersten Vorkommens eines Zeichens aus dem String "chars" in dem String "s".@{PAR} @{RSLT}Rückgabe@{URSLT} Der Index eines Zeichens oder die Länge des Strings "s". @ENDNODE @NODE strerror "strerror" @{FUNC}strerror@{UFUNC} Fehlermeldung zu einem Fehlerwert@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} msg = strerror(error);@{PAR} char *msg;@{PAR} int error;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert einen Zeiger auf eine Fehlermeldung, die zu dem Wert "error" gehört. Dieser String darf nicht verändert werden.@{PAR} @{RSLT}Rückgabe@{URSLT} Zeiger auf einen Fehlermeldungsstring.@{PAR} @{SEE}Siehe auch@{USEE} @{" perror " LINK "perror"}@{PAR} @ENDNODE @NODE strftime "strftime" @{FUNC}strftime@{UFUNC} Formatierte Ausgabe einer Datums- und Zeitangabe in einen String@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = strftime(s,size,format,tp);@{PAR} size_t r;@{PAR} char *s;@{PAR} size_t size;@{PAR} const char *format;@{PAR} const struct tm *tp;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Gibt das Datum und die Zeit je nach @{"Zeit-Format-String" LINK "ZeitFormatString"} in einen String aus. Der String "s" muß genügend Speicherplatz zur Aufnahme der Ausgabe haben, inklusive des Nullzeichens das immer angehängt wird.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Anzahl der ausgegebenen Zeichen.@{PAR} @ENDNODE @NODE stricmp "stricmp" @{FUNC}stricmp@{UFUNC} Vergleich zweier Strings@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = stricmp(left,right);@{PAR} int r;@{PAR} const char *left;@{PAR} const char *right;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Vergleicht die beiden Strings zeichenweise ohne Beachtung von Groß- und Kleinschreibung der Buchstaben. Die Funktion liefert 0 falls beide Strings gleich sind, einen Wert kleiner 0 wenn das erste unterschiedliche Zeichen aus String "left" kleiner ist als aus String "right" und einen Wert größer 0 wenn das erste unterschiedliche Zeichen aus String "left" größer ist als aus String "right".@{PAR} @{RSLT}Rückgabe@{URSLT} 0, wenn beide Strings gleich sind, <0 wenn der erste String kleiner als der zweite ist, >0 wenn der erste String größer als der zweite ist.@{PAR} @{SEE}Siehe auch@{USEE} @{" strcmp " LINK "strcmp"}@{PAR} @ENDNODE @NODE strlen "strlen" @{FUNC}strlen@{UFUNC} Länge eines Strings@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} length = strlen(s);@{PAR} size_t length;@{PAR} const char *s;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert die Länge eines Strings. Das abschließende Nullzeichen wird nicht zur Länge gezählt. Eventuelle Escapesequenzen (z.B. "\n" oder "\t") im Quelltext sind alle in ein Zeichen übersetzt.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Länge des Strings ohne das Nullzeichen.@{PAR} @ENDNODE @NODE strncat "strncat" @{FUNC}strncat@{UFUNC} Anhängen einer Zeichenkette mit Längenbegrenzung@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = strncat(s,t,n);@{PAR} char *r;@{PAR} char *s;@{PAR} char *t;@{PAR} size_t n;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Hängt den String "t" an den String "s" an, dabei wird jedoch eine maximale Gesamtlänge von "n" Zeichen berücksichtigt. Würde der Gesamtstring zu lang, wird er nach der Länge "n" geschnitten.@{PAR} @{RSLT}Rückgabe@{URSLT} Einen Zeiger auf den String "s".@{PAR} @{SEE}Siehe auch@{USEE} @{" strcat " LINK "strcat"}@{PAR} @ENDNODE @NODE strncmp "strncmp" @{FUNC}strncmp@{UFUNC} Vergleich zweier Strings bei Beachtung einer Maximallänge@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = strncmp(left,right,n);@{PAR} int r;@{PAR} const char *left;@{PAR} const char *right;@{PAR} size_t n;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Vergleicht die beiden Strings bis maximal zum Zeichen mit Index "n". Liefert 0 wenn beide Strings bis zu diesem Zeichen gleich sind, einen Wert kleiner 0, wenn das erste unterschiedliche Zeichen aus String "left" kleiner ist als aus String "right" und einen Wert größer 0, wenn das erste unterschiedliche Zeichen aus String "left" größer ist als aus String "right".@{PAR} @{RSLT}Rückgabe@{URSLT} 0, wenn beide Teilstrings gleich sind, <0, wenn der erste String kleiner als der zweite ist, >0, wenn der erste String größer als der zweite ist.@{PAR} @{SEE}Siehe auch@{USEE} @{" strcmp " LINK "strcmp"}@{PAR} @ENDNODE @NODE strncpy "strncpy" @{FUNC}strncpy@{UFUNC} Kopieren eines Strings mit Längenbegrenzung.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} char *strncpy(char *s1, const char *s1, size_t n)@{PAR} char *r;@{PAR} char *dest;@{PAR} const char *source;@{PAR} size_t n;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Kopiert maximal n Zeichen aus dem String source in den String dest. Werden weniger als n Zeichen kopiert, so wird mindestens ein Nullbyte angehängt.@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf den Zielstring.@{PAR} @{SEE}Siehe auch@{USEE} @{" strcpy " LINK "strcpy"}@{PAR} @ENDNODE @NODE strpbrk "strpbrk" @{FUNC}strpbrk@{UFUNC} Suchen eines Zeichens einer Zeichenmenge in einer Zeichenkette@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} char *strpbrk(const char *s, const char *chars)@{PAR} char *r;@{PAR} const char *s;@{PAR} const char *chars;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert einen Zeiger auf das erste Zeichen im String "s", das auch im String "chars" enthalten ist.@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf die erste Übereinstimmung oder NULL.@{PAR} @ENDNODE @NODE strrchr "strrchr" @{FUNC}strrchr@{UFUNC} Das letzte Vorkommen eines Zeichens in einem String@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = strrchr(s,ch);@{PAR} char *r;@{PAR} const char *s;@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert das letzte Vorkommen des Zeichens "ch" in dem String "s".@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf das letzte Vorkommen des Zeichens "ch" im String.@{PAR} @{SEE}Siehe auch@{USEE} strchr@{PAR} @ENDNODE @NODE strspn "strspn" @{FUNC}strspn@{UFUNC} Suchen von Zeichen in einem String@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} index = strspn(s,chars);@{PAR} size_t index;@{PAR} const char *s;@{PAR} const char *chars;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert den Index des ersten Zeichens des Strings "s", das nicht in dem String "chars" vorkommt.@{PAR} @{RSLT}Rückgabe@{URSLT} Index des ersten Zeichens aus "chars", das nicht im String enthalten ist.@{PAR} @ENDNODE @NODE strstr "strstr" @{FUNC}strstr@{UFUNC} Suchen eines Strings in einem anderen.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = strstr(s,t);@{PAR} char *r;@{PAR} const char *s;@{PAR} const char *t;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Sucht den String "t" im String "s" und liefert das erste Vorkommen des Teilstrings.@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf den Teilstring innerhalb des Strings "s" oder NULL.@{PAR} @ENDNODE @NODE strtod "strtod" @{FUNC}strtod@{UFUNC} Konvertierung eines Strings in eine doppelt genaue Fließkommazahl.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} d = strtod(s,nextchar);@{PAR} double d;@{PAR} const char *s;@{PAR} char **nextchar;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Versucht den String "s" in eine Fließkommzahl doppelter Genauigkeit zu wandeln. Tritt dabei ein Fehler auf, wird die Fehlervariable errno gesetzt. Der Zeiger "nextchar" kann NULL sein oder auf eine Variable zeigen, die einen Zeiger auf das erste Zeichen erhält, das nicht mehr konvertiert werden konnte. @{RSLT}Rückgabe@{URSLT} Die konvertierte Zeichenkette als doppelt genaue Fließkommazahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" sscanf " LINK "sscanf"}@{PAR} @ENDNODE @NODE strtok "strtok" @{FUNC}strtok@{UFUNC} Zerlegen einer Zeichenkette@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = strtok(s,delimiters);@{PAR} char *r;@{PAR} char *s;@{PAR} const char *delimiters;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Zerlegt den String "s" in einzelne Stücke, deren Länge durch den String "delimiters" bestimmt wird. Beim ersten Aufruf der Funktion wird der erste Teilstring ermittelt, der bis zu dem ersten Vorkommen eines der Zeichen aus dem String "delimiters" reicht.@{PAR} Bei weiteren Aufrufen muß der Zeiger "s" NULL sein. Dadurch wird der nächste Teilstring ermittelt. Dies kann man solange fortsetzen bis kein weiterer Teilstring existiert und der String komplett zerlegt ist.@{PAR} @{ATT}Hinweis@{UATT} Zwischen den Aufrufen zur Zerlegung eines Strings darf dieser nicht verändert werden. Ebenso darf zwischen zwei Aufrufen für einen String "s" kein Aufruf für einen anderen String "t" liegen (was durch einen möglichen Unterprogrammaufruf manchmal schwer zu überprüfen ist).@{PAR} @{RSLT}Rückgabe@{URSLT} Zeiger auf einen Teilstring von "s" oder NULL, falls das Ende des Strings erreicht wurde.@{PAR} @ENDNODE @NODE strtol "strtol" @{FUNC}strtol@{UFUNC} Konvertierung eines Strings in eine ganze vorzeichenbehaftete Zahl.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = strtol(s,nextchar,base);@{PAR} long int r;@{PAR} const char *s;@{PAR} char **nextchar;@{PAR} int base;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Wandelt einen String "s" in eine ganze Zahl um. Dabei gibt "base" die Darstellungsbasis an, in der die Zahl vorliegt. @{PAR} Der Zeiger "nextchar" ist NULL oder zeigt auf eine Variable, die einen Zeiger auf das erste Zeichen im String erhält, das nicht konvertiert werden konnte.@{PAR} Diese Basis gibt als Wert zwischen 2 und 36 die Zahlbasis direkt an und erlaubt dann die Ziffern "0" bis "9" und die Buchstaben "a" bis "z" bzw "A" bis "Z". Die maximal zugelassene Ziffer ergibt sich aus der Basis.@{PAR} Ist dieser Basiswert jedoch 0, wird die Zahlbasisi aus dem String selbst ermittelt: Beginnt die Zahl mit "0" so ist sie oktal, beginnt sie mit "0x" oder "0X" so ist sie hexadezimal, in jedem anderen Fall ist sie dezimal.@{PAR} @{RSLT}Rückgabe@{URSLT} Die konvertierte vorzeichenbehaftete Zahl@{PAR} @{SEE}Siehe auch@{USEE} @{" atoi " LINK "atoi"}, @{" sscanf " LINK "sscanf"}@{PAR} @ENDNODE @NODE strtoul "strtoul" @{FUNC}strtoul@{UFUNC} Konvertierung eines Strings in eine ganze vorzeichenlose Zahl.@{PAR} @{SYN}Übrsicht@{USYN} #include @{PAR} r = strtoul(s,nextchar,base);@{PAR} long int r;@{PAR} const char *s;@{PAR} char **nextchar;@{PAR} int base;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Wandelt einen String "s" in eine ganze Zahl um. Dabei gibt "base" die Darstellungsbasis an, in der die Zahl vorliegt. @{PAR} Der Zeiger "nextchar" ist NULL oder zeigt auf eine Variable, die einen Zeiger auf das erste Zeichen im String erhält, das nicht konvertiert werden konnte.@{PAR} Diese Basis gibt als Wert zwischen 2 und 36 die Zahlbasis direkt an und erlaubt dann die Ziffern "0" bis "9" und die Buchstaben "a" bis "z" bzw "A" bis "Z". Die maximal zugelassene Ziffer ergibt sich aus der Basis.@{PAR} Ist dieser Basiswert jedoch 0, wird die Zahlbasisi aus dem String selbst ermittelt: Beginnt die Zahl mit "0" so ist sie oktal, beginnt sie mit "0x" oder "0X" so ist sie hexadezimal, in jedem anderen Fall ist sie dezimal.@{PAR} @{RSLT}Rückgabe@{URSLT} Die konvertierte vorzeichenlose Zahl@{PAR} @{SEE}Siehe auch@{USEE} @{" sscanf " LINK "sscanf"}@{PAR} @ENDNODE @NODE system "system" @{FUNC}system@{UFUNC} Ausführen eines CLI Kommandos@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = s ystem(command);@{PAR} int r;@{PAR} const char *command;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Führt das Kommando "command" synchron zum aktuellen Prozess als CLI Kommando aus.@{PAR} @{ATT}Hinweis@{UATT} Diese Funktion benutzt den AmigaDOS Befehl SystemTags ohne besondere Angabe von Tags. Deshalb wird immer die Benutzershell als Umgebung verwendet. Bei den meisten Amiga Usern ist dies die Amiga Shell, sie kann jedoch durch andere Shells ersetzt sein. Deshalb sollte man die Benutzung von shellspezifischen Spezialitäten vermeiden.@{PAR} @{RSLT}Rückgabe@{URSLT} Der Rückgabewert ist das Ergebnis der Funktion SystemTags und damit gleich dem Rückgabewert des ausgeführten Kommandos (0 im Erfolgsfall).@{PAR} @ENDNODE @NODE tan "tan" @{FUNC}tan@{UFUNC} Der Tangens@{PAR} @{SYN}Übersicht@{USYN} #include ;@{PAR} r = tan(x);@{PAR} double r;@{PAR} double x;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert den Tangens der doppelt genauen Gleitkommazahl "x".@{PAR} @{ATT}Hinweis@{UATT} Bei den trigonometrichen Funktionen werden Winkel natürlich im Bogenmaß (Radian) angegeben. Ein Gradwinkel "w" läßt sich mit der Formel:@{PAR} x = 3.14159265358979/180.0 * w@{PAR} in Bogenmaß umrechnen.@{PAR} @{RSLT}Rückgabe@{URSLT} Der Tangens als doppelt genaue Gleitkommazahl@{PAR} @{SEE}Siehe auch@{USEE} @{" atan " LINK "atan"}, @{" sin " LINK "sin"}, @{" cos " LINK "cos"}@{PAR} @ENDNODE @NODE tanh "tanh" @{FUNC}tanh@{UFUNC} Der Tangens Hyperbolicus@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = tanh(x);@{PAR} double r;@{PAR} double x;@{PAR} @{XPL}Erklärung@{UXPL} Liefert den Tangens Hyperbolicus der doppelt genauen Gleitkommazahl "x".@{PAR} @{ATT}Hinweis@{UATT} Bei den trigonometrichen Funktionen werden Winkel natürlich im Bogenmaß (Radian) angegeben. Ein Gradwinkel "w" läßt sich mit der Formel:@{PAR} x = 3.14159265358979/180.0 * w@{PAR} in Bogenmaß umrechnen.@{PAR} @{RSLT}Rückgabe@{URSLT} Der Tangens Hyperbolicus als doppelt genaue Gleitkommazahl.@{PAR} @ENDNODE @NODE time "time" @{FUNC}time@{UFUNC} Die aktuelle Systemzeit@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} t = time(tp);@{PAR} time_t t;@{PAR} time_t *tp;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Liefert die aktuelle Systemzeit in einem komprimierten Format. Der Parameter "tp" ist NULL oder zeigt auf eine Variable, die den Zeitwert aufnehmen soll.@{PAR} @{RSLT}Rückgabe@{URSLT} Die aktuelle Systemzeit.@{PAR} @ENDNODE @NODE tmpfile "tmpfile" @{FUNC}tmpfile@{UFUNC} Erzeugen einer temporären Datei.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} f = tmpfile();@{PAR} FILE *f;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Erzeugt eine neue Datei mit einem eindeutigen Dateinamen für temporäre Benutzung. Die Datei wird spätestens am Programmende automatisch gelöscht.@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf den Dateihandle.@{PAR} @{SEE}Siehe auch@{USEE} @{" tmpnam " LINK "tmpnam"}, @{" fopen " LINK "fopen"}, @{" fclose " LINK "fclose"}@{PAR} @ENDNODE @NODE tmpnam "tmpnam" @{FUNC}tmpnam@{UFUNC} Erzeugen eines eindeutigen Dateinamens@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = tmpnam(name);@{PAR} char *r;@{PAR} char name[L_tmpnam];@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Erzeugt einen im System eindeutigen Dateinamen, der für temporäre Dateien benutzt werden kann.@{PAR} @{RSLT}Rückgabe@{URSLT} Ein Zeiger auf den Dateinamen "name".@{PAR} @{SEE}Siehe auch@{USEE} @{" tmpfile " LINK "tmpfile"}@{PAR} @ENDNODE @NODE tolower "tolower" @{FUNC}tolower@{UFUNC} Groß- in Kleinbuchstaben wandeln@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = tolower(ch);@{PAR} int r;@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Falls das Zeichen "ch" ein Großbuchstabe ist, wird es in einen Kleinbuchstaben gewandelt, ansonsten bleibt es unverändert. Aus Gründen der Portierbarkeit werden nur die Buchstaben "A" bis "Z" beachtet, Umlaute werden unverändert zurückgegeben.@{PAR} @{RSLT}Rückgabe@{URSLT} Das gewandelte Zeichen.@{PAR} @{SEE}Siehe auch@{USEE} @{" toupper " LINK "toupper"}@{PAR} @ENDNODE @NODE toupper "toupper" @{FUNC}toupper@{UFUNC} Klein- in Großbuchstaben wandeln@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = toupper(ch);@{PAR} int r;@{PAR} int ch;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Falls das Zeichen "ch" ein Kleinbuchstabe ist, wird es in einen Großbuchstaben gewandelt, ansonsten bleibt es unverändert. Aus Gründen der Portierbarkeit werden nur die Buchstaben "a" bis "z" beachtet, Umlaute werden unverändert zurückgegeben.@{PAR} @{RSLT}Rückgabe@{URSLT} Das gewandelte Zeichen.@{PAR} @{SEE}Siehe auch@{USEE} @{" tolower " LINK "tolower"}@{PAR} @ENDNODE @NODE ungetc "ungetc" @{FUNC}ungetc@{UFUNC} Zurückstellen eines Zeichens in eine Datei@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = ungetc(ch,f);@{PAR} int r;@{PAR} int ch;@{PAR} FILE *f;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Stellt das Zeichen "ch" in die Datei "f" zurück. Es kann maximal ein Zeichen zurückgestellt werden.@{PAR} @{RSLT}Rückgabe@{URSLT} Das zurückgestelte Zeichen oder EOF im Fehlerfall.@{PAR} @{SEE}Siehe auch@{USEE} @{" getc " LINK "getc"}@{PAR} @ENDNODE @NODE va_arg "va_arg" @{FUNC}va_arg@{UFUNC} Ermitteln des nächsten Parameters einer variablen Parameterliste@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} r = va_arg(vl,TYPE);@{PAR} TYPE r; // nächster Parameter der Funktion@{PAR} va_list vl; // Parameterliste@{PAR} TYPE; // Typ des Parameters@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Ermittelt den nächsten Parameter aus einer variablen Parameterliste. Der Typ dieses Parameters muß bekannt sein, z.B. durch einen Formatstring, wie ihn die Funktionen printf und scanf benutzen.@{PAR} Vor der Benutzung dieses Makros muß die Parameterliste mit va_start initialisiert werden. Nach dem letzten Parameter muß die Parameterliste mit va_end abgeschlossen werden.@{PAR} @{RSLT}Rückgabe@{URSLT} Der Wert des nächsten Arguments@{PAR} @{SEE}Siehe auch@{USEE} @{" va_start " LINK "va_start"}, @{" va_end " LINK "va_end"}@{PAR} @ENDNODE @NODE va_end "va_end" @{FUNC}va_end@{UFUNC} Beenden der Auswertung einer variablen Parameterliste@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} va_end(vl);@{PAR} va_list vl; // Parameterliste@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Dieses Makro beendet die Auswertung der Parameterliste und muß unbedingt verwendet werden, um Kompatibilität und Portabilität zu gewährleisten.@{PAR} @{SEE}Siehe auch@{USEE} @{" va_start " LINK "va_start"}, @{" va_arg " LINK "va_arg"}@{PAR} @ENDNODE @NODE va_start "va_start" @{FUNC}va_start@{UFUNC} Initialisieren einer variablen Parameterliste@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} va_start(vl,LASTPAR);@{PAR} va_list vl; // Parameterliste@{PAR} LASTPAR; // Der Name des lezten Parameters mit beganntem Typ@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Initialisiert eine variable Parameterliste einer Funktion.@{PAR} Das Makro "va_start" initialisiert die Variable "vl" mit Hilfe des letzen Parameters der Funktion, der einen festen Typ hat.@{PAR} Nur dieses Makro garantiert die richtige Verwendung der Parameter auch in inline Funktionen und in portierbaren Programmen.@{PAR} @{SEE}Siehe auch@{USEE} @{" va_arg " LINK "va_arg"}, @{" va_end " LINK "va_end"}@{PAR} @ENDNODE @NODE vprintf "vprintf" @{FUNC}vprintf@{UFUNC} Formatierte Ausgabe in die Standardausgabe@{PAR} @{SYN}Übersicht@{USYN} #include r = vprintf(format,vl);@{PAR} int r;@{PAR} const char *format;@{PAR} va_list vl;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Formatierte Ausgabe auf der Standardausgabe stdout. Der @{"Ausgabe-Format-String" LINK "AusgabeFormatString"} beschreibt das Format der Ausgabe, danach folgt eine Parameterliste "vl".@{PAR} Die Parameterliste "vl" muß vor dem Aufruf mit va_start initialisiert werden und nach dem Aufruf mit va_end abgeschlossen werden.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" vfprintf " LINK "vfprintf"}, @{" vsprintf " LINK "vsprintf"}, @{" printf " LINK "printf"}@{PAR} @ENDNODE @NODE vfprintf "vfprintf" @{FUNC}vfprintf@{UFUNC} Formatierte Ausgabe in eine Datei@{PAR} @{SYN}Übersicht@{USYN} #include r = vfprintf(f,format,vl);@{PAR} int r;@{PAR} FILE *f;@{PAR} const char *format;@{PAR} va_list vl;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Formatierte Ausgabe in die Datei "f". Der @{"Ausgabe-Format-String" LINK "AusgabeFormatString"} beschreibt das Format der Ausgabe, danach folgt eine Parameterliste "vl".@{PAR} Die Parameterliste "vl" muß vor dem Aufruf mit va_start initialisiert werden und nach dem Aufruf mit va_end abgeschlossen werden.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" vprintf " LINK "vprintf"}, @{" fprintf " LINK "fprintf"}@{PAR} @ENDNODE @NODE vsprintf "vsprintf" @{FUNC}vsprintf@{UFUNC} Formatierte Ausgabe in einen String@{PAR} @{SYN}Übersicht@{USYN} #include r = vsprintf(s,format,vl);@{PAR} int r;@{PAR} char *s;@{PAR} const char *format;@{PAR} va_list vl;@{PAR} @{PORT}Portabilität@{UPORT} ANSI@{PAR} @{XPL}Erklärung@{UXPL} Formatierte Ausgabe in den String "s". Der @{"Ausgabe-Format-String" LINK "AusgabeFormatString"} beschreibt das Format der Ausgabe, danach folgt eine Parameterliste "vl".@{PAR} Der Speicherbereich für den String "s" muß mindestens so groß sein, daß die Ausgabe mit abschließenden Nullzeichen hineinpaßt.@{PAR} Die Parameterliste "vl" muß vor dem Aufruf mit va_start initialisiert werden und nach dem Aufruf mit va_end abgeschlossen werden.@{PAR} @{RSLT}Rückgabe@{URSLT} Die Anzahl der ausgegebenen Zeichen oder im Fehlerfall eine negative Zahl.@{PAR} @{SEE}Siehe auch@{USEE} @{" vprintf " LINK "vprintf"}, @{" sprintf " LINK "sprintf"}@{PAR} @ENDNODE @NODE cin "cin" @{FUNC}cin@{UFUNC} Ein istream Objekt, das von der Standardeingabe liest.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} cin >> x;@{PAR} x; // Jeder Typ, für den istream::operator>> verfügbar ist@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Bei Programmstart wird die Variable cin initialisiert mit der Standardeingabedatei, im Normalfall ist dies die Konsole des CLI aus dem das Program gestartet wurde.@{PAR} @{SEE}Siehe auch@{USEE} @{" cout " LINK "cout"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} void main()@{PAR} {@{PAR} char name[80];@{PAR} unsigned int alter;@{PAR} cout << "Bitte geben Sie Ihren Namen und das Alter ein: ";@{PAR} cin >> name >> alter;@{PAR} }@{PAR} @ENDNODE @NODE cout "cout" @{FUNC}cout@{UFUNC} Ein ostream Objekte, das auf die Standardausgabe schreibt.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} cout << x;@{PAR} x; // Jeder Typ, für den ostream::operator<< verfügbar ist@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Bei Programmstart wird die Variable cout initialisiert mit der Standardausgabedatei, im Normalfall ist dies die Konsole des CLI aus dem das Programm gestartet wurde.@{PAR} @{SEE}Siehe auch@{USEE} @{" cerr " LINK "cerr"}, @{" clog " LINK "clog"}, @{" cin " LINK "cin"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} void main()@{PAR} {@{PAR} cout << "Hallo Welt!" << endl;@{PAR} }@{PAR} @ENDNODE @NODE cerr "cerr" @{FUNC}cerr@{UFUNC} Ein ostream Objekte, das in die Standardfehlerdatei schreibt.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} cerr << x;@{PAR} x; // Jeder Typ, für den ostream::operator<< verfügbar ist@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Bei Programmstart wird die Variable cerr initialisiert mit der Standardausgabedatei, da das AmigaOS nicht zwischen Standardausgabe und Standardfehlerausgabe unterscheidet. Im Normalfall ist dies die Konsole des CLI aus dem das Programm gestartet wurde.@{PAR} @{SEE}Siehe auch@{USEE} @{" cout " LINK "cout"}, @{" clog " LINK "clog"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} void main()@{PAR} {@{PAR} cerr << "Das Programm wurde mit dem "@{PAR} "Fehler unerwartet beendet" << endl;@{PAR} }@{PAR} @ENDNODE @NODE clog "clog" @{FUNC}clog@{UFUNC} Ein ostream Objekte, das in die Standardlogdatei schreibt.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} clog << x;@{PAR} x; // Jeder Typ, für den ostream::operator<< verfügbar ist@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Bei Programmstart wird die Variable clog initialisiert mit der Standardausgabedatei, da das AmigaOS nicht zwischen Standardausgabe und Standardlogausgabe unterscheidet. Im Normalfall ist dies die Konsole des CLI aus dem das Programm gestartet wurde.@{PAR} @{SEE}Siehe auch@{USEE} @{" cout " LINK "cout"}, @{" cerr " LINK "cerr"}@{PAR} @{XMPL}Beispiel@{UXMPL} #include @{PAR} #include @{PAR} void main()@{PAR} {@{PAR} clog << "Das Programm lief " << clock() / CLOCKS_PER_SEC << " sec." << endl;@{PAR} }@{PAR} @ENDNODE @NODE fstream "fstream" @{FUNC}fstream@{UFUNC} Eine Klasse für Datei Ein- und Ausgabe@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} class fstream : public iostream {@{PAR} public:@{PAR} fstream();@{PAR} fstream(const char *, int);@{PAR} virtual ~fstream();@{PAR} void open(const char *, int);@{PAR} void close();@{PAR} filebuf *rdbuf();@{PAR} };@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Die Klasse fstream stellt einen Ein- und Ausgabe stream auf Dateien zur Verfügung. Sie verwendet die Klasse filebuf als streambuf.@{PAR} @{MTHD}Konstruktoren@{UMTHD} fstream::fstream();@{PAR} Initialisiert ein Objekt ohne eine Datei zu öffnen.@{PAR} fstream::fstream(const char *, int);@{PAR} Initialisiert ein Objekt und öffnet die angegebene Datei.@{PAR} @{MTHD}Destruktoren@{UMTHD} fstream::~fstream();@{PAR} Schließt die eventuell offene Datei.@{PAR} @{MTHD}Methoden@{UMTHD} void open(const char *, int);@{PAR} Öffnet die Datei mit dem angegebenen Namen und dem gewünschten Modus.@{PAR} void close();@{PAR} Schließt die Datei.@{PAR} filebuf *rdbuf();@{PAR} Git einen Pointer auf den verwendeten Dateipuffer zurück.@{PAR} @{SEE}Siehe auch@{USEE} @{" iostream " LINK "iostream"}, @{" ifstream " LINK "ifstream"}, @{" ofstream " LINK "ofstream"}, @{" filebuf " LINK "filebuf"}@{PAR} @ENDNODE @NODE ifstream "ifstream" @{FUNC}ifstream@{UFUNC} Eine Klasse für Datei Eingabe.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} class ifstream : public istream {@{PAR} public:@{PAR} ifstream();@{PAR} ifstream(const char *, int = ios::in);@{PAR} virtual ~ifstream();@{PAR} void open(const char *, int = ios::in);@{PAR} void close();@{PAR} filebuf *rdbuf();@{PAR} };@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Die Klasse ifstream stellt einen Eingabe stream auf Dateien zur Verfügung. Sie verwendet die Klasse filebuf als streambuf.@{PAR} @{MTHD}Konstruktoren@{UMTHD} ifstream::ifstream();@{PAR} Initialisiert ein Objekt ohne eine Datei zu öffnen.@{PAR} ifstream::ifstream(const char *, int); Initialisiert ein Objekt und öffnet die angegebene Datei.@{PAR} @{MTHD}Destruktoren@{UMTHD} ifstream::~ifstream();@{PAR} Schließt die eventuell offene Datei.@{PAR} @{MTHD}Methoden@{UMTHD} void open(const char *, int);@{PAR} Öffnet die Datei mit dem angegebenen Namen und dem gewünschten Modus.@{PAR} void close();@{PAR} Schließt die Datei.@{PAR} filebuf *rdbuf();@{PAR} Gibt einen Pointer auf den verwendeten Dateipuffer zurück.@{PAR} @{SEE}Siehe auch@{USEE} @{" istream " LINK "istream"}, @{" fstream " LINK "fstream"}, @{" ofstream " LINK "ofst ream"}, @{" filebuf " LINK "filebuf"}@{PAR} @ENDNODE @NODE ofstream "ofstream" @{FUNC}ofstream@{UFUNC} Eine Klasse für Datei Ausgabe.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} class ofstream : public ostream {@{PAR} public:@{PAR} ofstream();@{PAR} ofstream(const char *, int = ios::out);@{PAR} virtual ~ofstream();@{PAR} void open(const char *, int = ios::out);@{PAR} void close();@{PAR} void setbuf(char *, size_t);@{PAR} filebuf *rdbuf();@{PAR} };@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Die Klasse ofstream stellt einen Ausgabe stream auf Dateien zur Verfügung. Sie verwendet die Klasse filebuf als streambuf.@{PAR} @{MTHD}Konstruktoren@{UMTHD} ofstream::ofstream();@{PAR} Initialisiert ein Objekt ohne eine Datei zu öffnen.@{PAR} ofstream::ofstream(const char *, int);@{PAR} Initialisiert ein Objekt und öffnet die angegebene Datei.@{PAR} @{MTHD}Destruktoren@{UMTHD} ofstream::~ofstream();@{PAR} Schließt die eventuell offene Datei.@{PAR} @{MTHD}Methoden@{UMTHD} void open(const char *, int);@{PAR} Öffnet die Datei mit dem angegebenen Namen und dem gewünschten Modus.@{PAR} void close();@{PAR} Schließt die Datei.@{PAR} filebuf *rdbuf();@{PAR} Gibt einen Pointer auf den verwendeten Dateipuffer zurück.@{PAR} @{SEE}Siehe auch@{USEE} @{" ostream " LINK "ostream"}, @{" fstream " LINK "fstream"}, @{" ifstream " LINK "ifstream"}, @{" filebuf " LINK "filebuf"}@{PAR} @ENDNODE @NODE ios "ios" @{FUNC}ios@{UFUNC} Eine Basisklasse zur Streammanipulation und Anbindung von Streampuffern an Streams.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} class ios {@{PAR} public:@{PAR} enum io_state {@{PAR} goodbit = 0x00,@{PAR} eofbit = 0x01,@{PAR} failbit = 0x02,@{PAR} badbit = 0x04,@{PAR} hardfail = 0x80@{PAR} };@{PAR} enum open_mode {@{PAR} in = 0x01,@{PAR} out = 0x02,@{PAR} ate = 0x04,@{PAR} app = 0x08,@{PAR} trunc = 0x10,@{PAR} nocreate = 0x20,@{PAR} noreplace = 0x40,@{PAR} binary = 0x80@{PAR} };@{PAR} enum seek_dir {@{PAR} beg = -1,@{PAR} cur = 0,@{PAR} end = 1@{PAR} };@{PAR} enum {@{PAR} skipws = 0x00000001,@{PAR} left = 0x00000002,@{PAR} right = 0x00000004,@{PAR} internal = 0x00000008,@{PAR} dec = 0x00000010,@{PAR} oct = 0x00000020,@{PAR} hex = 0x00000040,@{PAR} showbase = 0x00000080,@{PAR} showpoint = 0x00000100,@{PAR} uppercase = 0x00000200,@{PAR} showpos = 0x00000400,@{PAR} scientific = 0x00000800,@{PAR} fixed = 0x00001000,@{PAR} unitbuf = 0x00002000,@{PAR} stdio = 0x00004000,@{PAR} firstfreebit = 0x00008000@{PAR} };@{PAR} ios(streambuf *b);@{PAR} virtual ~ios();@{PAR} unsigned long flags();@{PAR} unsigned long flags(unsigned long f);@{PAR} unsigned long setf(unsigned long f);@{PAR} unsigned long unsetf(unsigned long f);@{PAR} unsigned long setf(unsigned long f, unsigned long m);@{PAR} int width();@{PAR} int width(int w);@{PAR} ostream *tie();@{PAR} ostream *tie(ostream *o);@{PAR} char fill();@{PAR} char fill(char f);@{PAR} int precision();@{PAR} int precision(int p);@{PAR} int rdstate();@{PAR} int eof();@{PAR} int fail();@{PAR} int bad();@{PAR} int good();@{PAR} void clear(int i = 0);@{PAR} operator void *();@{PAR} int operator !();@{PAR} streambuf* rdbuf();@{PAR} static void sync_with_stdio();@{PAR} static unsigned long bitalloc();@{PAR} static int xalloc();@{PAR} long &iword(int i);@{PAR} void *&pword(int i);@{PAR} static const unsigned long basefield;@{PAR} static const unsigned long adjustfield;@{PAR} static const unsigned long floatfield;@{PAR} protected:@{PAR} ios();@{PAR} void init(streambuf *);@{PAR} streambuf *aBuf;@{PAR} int aState;@{PAR} ostream *aTie;@{PAR} short int aPrecision;@{PAR} char aFill;@{PAR} short aWidth;@{PAR} unsigned long aFlags;@{PAR} };@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Die Klasse ios ist die Basisklasse für alle Streamklassen, insbesondere ostream, istream und iostream. Sie definiert einige Aufzähltypen durch die der Zustand des Streams, der Streammodus, die Formatierungen der Ein- und Ausgabe sowie die Suchrichtung in Streams beschrieben werden. Desweiteren bindet sie Ein- und Ausgabestreams aneinader und ermöglicht die Erweiterung der Streamdefinition um neue Formatierungen und Statusvariablen durch abgeleitete Klassen.@{PAR} Typen enum ios::io_state {@{PAR} goodbit, eofbit, failbit, badbit, hardfail@{PAR} };@{PAR} Die Statusflags spiegeln den Zustand des streams wieder.@{PAR} goodbit ist kein Flag, sondern ein symbolischer Name für den Zustand, in dem alle anderen Flags gelöscht sind und bedeutet, daß der stream völlig in Ordnung ist.@{PAR} eofbit ist gesetzt, wenn bei der Eingabe EOF erreicht wurde.@{PAR} failtbit wird durch einen Ein- oder Ausgabe Fehler gesetzt. z.B. Formatierungsfehler.@{PAR} badbit wird ebenfalls durch Ein- oder Ausgabe Fehler gesetzt, ein sinnvolles Fortsetzen der Ein- oder Ausgabe auf diesem stream ist nicht mehr möglich.@{PAR} hardfail wird gesetzt, wenn gar nichts mehr geht und der innere Zustand des stream irreparabel ist.@{PAR} enum ios::open_mode {@{PAR} in, out, ate, app, trunc, nocreate, noreplace, binary@{PAR} };@{PAR} Diese Flags können beim Öffnen einer Datei angegeben werden.@{PAR} in öffnet die Datei zum Lesen.@{PAR} out öffnet die Datei zum Schreiben.@{PAR} ate öffnet die Datei und setzt den Dateizeiger an das Ende der Datei.@{PAR} app öffnet die Datei zum Anhängen, jede Ausgabe wird an das Ende der Datei angefügt.@{PAR} trunc öffnet die Datei und setzt die Länge auf 0.@{PAR} nocreate verhindert die Erzeugung einer neuen Datei beim Öffnen.@{PAR} noreplace verhindert das Öffnen einer alten Datei.@{PAR} binary ist unter AmigaOS sinnlos, da es keinen Unterschied zwischen Text und Binärdateien gibt.@{PAR} Nicht jede Kombination der Flags ist sinnvoll (z.B ios::nocreate| ios::noreplace). Sobald eine Datei zum Schreiben geöffnet wird, wird sie exklusiv gesperrt, unabhängig davon, ob eine alte Datei geöffnet wird oder eine neu Datei angelegt.@{PAR} enum ios::seek_dir {@{PAR} beg, cur, end@{PAR} };@{PAR} Diese Aufzählungswerte bestimmen die relative Startposition einer Positionssuche in einem stream.@{PAR} beg beginnt die Suche am Anfang des streams.@{PAR} cur beginnt die Suche ab der aktuell gültigen Position.@{PAR} end beginnt die Suche am Ende des streams.@{PAR} enum {@{PAR} skipws, left, right, internal, dec, oct, hex, showbase,@{PAR} showpoint, uppercase, showpos, scientific, fixed,@{PAR} unitbuf, stdio, firstfreebit@{PAR} };@{PAR} Diese Flags legen die Formatierung der nächsten Ausgabe oder Eingabe fest.@{PAR} skipws läßt whitespace Zeichen bei der Eingabe überlesen, darunter fallen Leerzeichen, Tabulatoren, eilenumbrüche etc.@{PAR} left justiert eine Ausgabe linksbündig, wenn die Feldbreite länger als die Ausgabe ist.@{PAR} right justiert die Ausgabe entsprechend rechtsbündig.@{PAR} internal fügt die Füllzeichen zwischen einem eventuell vorkommenden Minuszeichen und der Zahl ein, hat die Zahl kein Minuszeichen oder wird keine Zahl ausgegeben, so erfolgt die Justierung rechtsbündig.@{PAR} dec setzt die Zahlbasis auf 10.@{PAR} oct setzt die Zahlbasis auf 8.@{PAR} hex setzt die Zahlbasis auf 16.@{PAR} showbase zeigt bei der Ausgabe einer Zahl die Zahlbasis an, "0" für eine oktale Zahl, "0x" oder "0X" für eine hexdezimale Zahl, ansonsten ist die Zahl im Dezimalsystem.@{PAR} showpoint erzwingt die Ausgabe eines Dezimalpunktes einer Fließkommazahl.@{PAR} uppercase benutzt Großbuchstaben bei der Ausgabe einer Hexadezimalzahl oder dem Exponent einer Fließkommazahl.@{PAR} showpos erzwingt die Ausgabe eines Vorzeichens auch wenn die Zahl positiv ist, das Vorzeichen ist entsprechend "+" oder "-".@{PAR} scientific gibt eine Fließkommazahl immer in Exponentschreibweise aus.@{PAR} fixed gibt eine Fließkommazahl immer in Festkommadarstellung aus.@{PAR} Ist keines dieser beiden Flags gesetzt, so wird die Zahl in gemischter Schreibweise ausgegeben, welche der beiden vorigen Formate benutzt wird, ist von der Größe und Genauigkeit der Zahl abhängig.@{PAR} unitbuf veranlaßt ein flush des Streampuffers nach jeder formatierten Ausgabe. Nicht empfehlenswert.@{PAR} stdio und firstfreebit sind intern benutzte Flags.@{PAR} Die Formatierungsflags left, right und internal bilden zusammen die Gruppe adjustfield, die Flags dec, oct und hex bilden die Gruppe basefield und die Flags scientific und fixed bilden die Gruppe floatfield.@{PAR} @{MTHD}Konstruktoren@{UMTHD} ios::ios(streambuf *);@{PAR} Initialisiert das stream Objekt und bindet den angegebenen Streampuffer an den stream. Der Pointer auf den Puffer sollte nicht NULL sein, sonst ist das Verhalten undefiniert.@{PAR} ios::ios(); Initialisiert das stream Objekt ohne Bindung eines Streampuffers.@{PAR} @{MTHD}Destruktoren@{UMTHD} ios::~ios();@{PAR} Dient vor allen Dingen dazu, einen virtuellen Destruktor einzuführen und schließt damit auch den stream.@{PAR} @{MTHD}Methoden@{UMTHD} unsigned long ios::flags();@{PAR} Ermittelt die aktuellen Formatierungsflags.@{PAR} unsigned long ios::flags(unsigned long f);@{PAR} Setzt die Formatierungsflags neu und gibt die alten Flags zurück.@{PAR} unsigned long ios::setf(unsigned long f);@{PAR} Setzt neue Formatierungsflags und gibt den alten Zustand dieser Flags zurück.@{PAR} unsigned long ios::unsetf(unsigned long f);@{PAR} Löscht Formatierungsaflags und gibt den alten Zustand dieser Flags zurück.@{PAR} unsigned long ios::setf(unsigned long f, unsigned long m);@{PAR} Setzt eine Gruppe von Formatierungsflags und gibt den alten Zustand dieser Gruppe zurück. Manche der Flags sind zu Gruppen zusammengefasst, in denen nur je ein Flag gesetzt sein darf, in den Attributen ios::basefield, ios::floatfield und ios::adjustfield steht jeweils eine Maske die für diese Gruppen angegeben werden kann.@{PAR} int ios::width();@{PAR} Gibt die aktuelle Feldbreite zurück.@{PAR} int ios::width(int w);@{PAR} Setzt die Feldbreite und gibt den alten Wert zurück. Die Feldbreite gibt die Mindestzahl von Zeichen einer formatierten Ausgabe an, benötigt die Ausgabe mehr Zeichen als die Feldbreite angibt, so wird die Ausgabe dennoch nicht beschnitten. Bei der Auffüllung der Feldbreite wird das Füllzeichen und die Formatierungflags der Gruppe ios::adjustflags beachtet.@{PAR} ostream *ios::tie();@{PAR} Gibt den Ausgabestream zurück, an den dieser stream gebunden ist.@{PAR} ostream *ios::tie(ostream *);@{PAR} Setzt den Ausgabestream, an den dieser stream gebunden ist und gibt den alten Wert (der zuvor gebunden stream oder NULL) zurück. Normalerweise werden nur an istreams andere stream angebunden. Diese Bindung ist insbesondere für cin und cout sinnvoll, den dadurch wird vor jeder Eingabe der Ausgabestream geflusht, um formatierte Ein-/Ausgabe zu ermöglichen.@{PAR} @{XMPL}Beispiel@{UXMPL}: #include @{PAR} void main()@{PAR} {@{PAR} int zahl;@{PAR} cout << "Bitte Zahl eingeben: ";@{PAR} cin >> zahl;@{PAR} }@{PAR} Nur dadurch, daß cout an cin gebunden ist, wird vor der Eingabe cout geflusht und damit der Text ausgegeben, ansonsten müßte man die Ausgabe manuell mit cout << flush erzwingen.@{PAR} char ios::fill();@{PAR} Gibt das Füllzeichen zurück, das verwendet wird, wenn die eingestellte Feldbreite größer ist als die Zahl der ausgegebenen Zeichen.@{PAR} char ios::fill(char f);@{PAR} Setzt das Füllzeichen und gibt das alte zurück.@{PAR} int ios::precision();@{PAR} Gibt die Genauigkeit bei Fließkommazahlausgabe zurück.@{PAR} int ios::precision(int);@{PAR} Setzt die Genauigkeit bei Fließkommzahlausgabe, d.h. die Anzahl der benutzten Nachkommastallen.@{PAR} int ios::rdstate();@{PAR} Gibt den Status des Streams zurück. Dieser Status wird durch jede Ausgabe oder Eingabe gesetzt, wenn einmal ein Fehler aufgetreten ist, werden weitere Ein- bzw. Ausgaben unterbunden.@{PAR} int ios::eof();@{PAR} Gibt ios::eofbit zurück, falls bei der letzten Eingabe ein EOF gelesen wurde, sonst 0.@{PAR} int ios::fail();@{PAR} Gibt einen Wert ungleich 0 zurück, wenn ein Fehler bei der Ein- oder Ausgabe aufgetreten ist.@{PAR} int ios::bad();@{PAR} Gibt einen Wert ungleich 0 zurück, wenn ein schwerer Fehler bei der Ein- oder Ausgabe aufgetreten ist.@{PAR} int ios::good();@{PAR} Gibt 1 zurück, wenn der stream in Ordnung ist und nicht einmal EOF gelesen wurde, sonst 0. Nur wenn diese Methode 1 liefert, werden weitere Ein- oder Ausgabe durchgeführt.@{PAR} void ios::clear(int i = 0);@{PAR} Setzt den Statuswert normalerweise auf 0. Sollte nicht benutzt werden, um auf einem beschädigten Stream weitere Ein- oder Ausgaben machen zu können, es sind sonst nur weitere Fehler zu erwarten.@{PAR} ios::operator void *();@{PAR} Liefert das Objekt selbst, wenn der stream keinen Fehler hat (sprich: !fail()), sonst NULL.@{PAR} int ios::operator !();@{PAR} Enspricht fail().@{PAR} streambuf* ios::rdbuf();@{PAR} Liefert den Streampuffer, der an diesen Stream gebunden ist.@{PAR} static void ios::sync_with_stdio();@{PAR} Synchronisiert den stream mit dem Standard I/O, d.h. flushed die Standard I/O Puffer.@{PAR} static unsigned long ios::bitalloc();@{PAR} Liefert das nächste unbenutzte Formatierungsflag oder 0, falls kein Flag mehr frei ist. Die Reservierung gilt für alle stream Objekte gleichzeitig.@{PAR} static int ios::xalloc();@{PAR} Liefert einen Index einer neuen Statusvariable. Die Reservierung gilt für alle stream Objekte gleichzeitig.@{PAR} long &ios::iword(int i);@{PAR} Liefert eine Referenz auf die Statusvariable mit dem Index i, der zuvor mit ios::xalloc() reserviert wurde.@{PAR} void *&ios::pword(int i);@{PAR} Liefert eine Referenz auf dei Statusvariable mit dem Index i, der zuvor mit ios::xalloc() reserviert wurde. Hierbei wird jedoch im Unterschied zu ios::iword() die Statusvariable als Pointertyp angenommen.@{PAR} @{SEE}Siehe auch@{USEE} @{" istream " LINK "istream"}, @{" ostream " LINK "ostream"}@{PAR} @ENDNODE @NODE iostream "iostream" @{FUNC}iostream@{UFUNC} Eine Streamklasse zur Ein- und Ausgabe@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} class iostream : private virtual ios, public ostream, public istream {@{PAR} public:@{PAR} iostream(streambuf *);@{PAR} protected:@{PAR} iostream();@{PAR} };@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Durch Verknüpfung der beiden Klassen ostream und istream bildet diese Klasse eine Basis für alle bidirektionalen Streamklassen.@{PAR} @{MTHD}Konstruktoren@{UMTHD} iostream::iostream(streambuf *);@{PAR} Initialisiert die Streamklasse und bindet den angegebenen Puffer.@{PAR} iostream::iostream();@{PAR} Initialisiert die Streamklasse ohne Puffer.@{PAR} @{SEE}Siehe auch@{USEE} @{" ios " LINK "ios"}, @{" ostream " LINK "ostream"}, @{" istream " LINK "istream"}, @{" fstream " LINK "fstream"}@{PAR} @ENDNODE @NODE istream "istream" @{FUNC}istream@{UFUNC} Eine Streamklasse zur Eingabe@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} class istream : virtual public ios {@{PAR} public:@{PAR} istream(streambuf *b);@{PAR} virtual ~istream();@{PAR} public:@{PAR} int ipfx(int need = 0);@{PAR} void isfx();@{PAR} istream &operator >>(unsigned char *s);@{PAR} istream &operator >>(signed cha r *s);@{PAR} istream &operator >>(char *);@{PAR} istream &operator >>(char &);@{PAR} istream &operator >>(unsigned char &c);@{PAR} istream &operator >>(signed char &c);@{PAR} istream &operator >>(short &);@{PAR} istream &operator >>(unsigned short &);@{PAR} istream &operator >>(int &);@{PAR} istream &operator >>(unsigned int &);@{PAR} istream &operator >>(long &);@{PAR} istream &operator >>(unsigned long &);@{PAR} istream &operator >>(float &);@{PAR} istream &operator >>(double &);@{PAR} istream &operator >>(long double &);@{PAR} istream &operator >>(streambuf *);@{PAR} istream &operator >>(istream &(*f)(istream &));@{PAR} istream &operator >>(ios &(*f)(ios &));@{PAR} istream &get(char *, int, char = '\n');@{PAR} istream &get(unsigned char *s, int n, char delimiter = '\n');@{PAR} istream &get(signed char *s, int n, char delimiter = '\n');@{PAR} istream &getline(char *, int, char = '\n');@{PAR} istream &getline(unsigned char *s, int n, char delimiter = '\n');@{PAR} istream &getline(signed char *s, int n, char delimiter = '\n');@{PAR} istream &get(streambuf &, char = '\n');@{PAR} istream &get(signed char &c);@{PAR} istream &get(unsigned char &c);@{PAR} istream &get(char &);@{PAR} int get();@{PAR} istream &ignore(int = 1, int = EOF);@{PAR} istream &read(unsigned char *s, int n);@{PAR} istream &read(signed char *s, int n);@{PAR} istream &read(char *, int);@{PAR} int gcount();@{PAR} int peek();@{PAR} istream &putback(char c);@{PAR} int sync();@{PAR} istream &seekg(streampos);@{PAR} istream &seekg(streamoff, ios::seek_dir);@{PAR} streampos tellg();@{PAR} protected:@{PAR} istream();@{PAR} };@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Die Klasse istream bildet die Basisklasse für formatierte und unformatierte Streameingabe.@{PAR} @{MTHD}Konstruktoren@{UMTHD} istream::istream(streambuf *b);@{PAR} Initialisiert den Eingabestream und bindet den Puffer.@{PAR} @{MTHD}Methoden@{UMTHD} int istream::ipfx(int need = 0);@{PAR} Erledigt alle Aufgabe vor einer formatierten Eingabe und liefert EOF, falls dabei ein Fehler auftritt oder sogar schon vorlag. Ist need == 0 oder sind im Puffer weniger Zeichen als need angibt, so wird der gebundene Ausgabestream (siehe ios::tie()) geflusht. Ist need == 0 und das Formatierungsflag ios::skipws gesetzt, so werden alle Whitespaces vor der Eingabe überlesen.@{PAR} void istream::isfx();@{PAR} Erledigt alle Aufgaben nach einer Eingabe. Derzeit eine leere Funktion.@{PAR} istream &istream::operator >>(unsigned char *s);@{PAR} istream &istream::operator >>(signed char *s);@{PAR} istream &istream::operator >>(char *);@{PAR} Eingabe von Strings bis zum nächsten Whitespacezeichen. Die maximale Anzahl der Zeichen die gelesen werden soll, kann mit der Feldbreite festgesetzt werden, ist ios::width() != 0 so werden nicht mehr als ios::width()-1 Zeichen gelesen.@{PAR} istream &istream::operator >>(char &);@{PAR} istream &istream::operator >>(unsigned char &c);@{PAR} istream &istream::operator >>(signed char &c);@{PAR} Eingabe eines einzelnen Zeichens.@{PAR} istream &istream::operator >>(short &);@{PAR} istream &istream::operator >>(unsigned short &);@{PAR} istream &istream::operator >>(int &);@{PAR} Eingabe von ganzen Zahlen.@{PAR} istream &istream::operator >>(unsigned int &);@{PAR} istream &istream::operator >>(long &);@{PAR} istream &istream::operator >>(unsigned long &);@{PAR} Eingabe von ganzen vorzeichenlosen Zahlen.@{PAR} istream &istream::operator >>(float &);@{PAR} istream &istream::operator >>(double &);@{PAR} istream &istream::operator >>(long double &);@{PAR} Eingabe von Fließkommazahlen.@{PAR} istream &istream::operator >>(istream &(*f)(istream &));@{PAR} istream &istream::operator >>(ios &(*f)(ios &));@{PAR} Unterstützung für einfache Eingabemanipulatoren. Die angegebene Funktion wird aufgerufen, als Parameter wird das istream Objekt übergeben.@{PAR} istream &istream::get(char *, int n, char = '\n');@{PAR} istream &istream::get(unsigned char *s, int n, char delimiter = '\n');@{PAR} istream &istream::get(signed char *s, int n, char delimiter = '\n');@{PAR} Die Eingabe wird bis zum angegeben Begrenzungszeichen eingelesen, das Begrenzungszeichen wird ebenfalls mit in den Strings aufgenommen. Es werden maximal n-1 Zeichen gelesen, der String wird immer mit einem Nullzeichen abgeschlossen.@{PAR} istream &istream::getline(char *, int n, char = '\n');@{PAR} istream &istream::getline(unsigned char *s, int n, char delimiter = '\n');@{PAR} istream &istream::getline(signed char *s, int n, char delimiter = '\n');@{PAR} Die Eingabe wird bis zum angegeben Begrenzungszeichen eingelesen, das Begrenzungszeichen wird nicht mit in den Strings aufgenommen, aber auch nicht in den stream zurückgestellt. Es werden maximal n-1 Zeichen gelesen, der String wird immer mit einem null Zeichen abgeschlossen.@{PAR} istream &istream::get(signed char &c);@{PAR} istream &istream::get(unsigned char &c);@{PAR} istream &istream::get(char &);@{PAR} Eingabe eines einzelnen Zeichens.@{PAR} int istream::get();@{PAR} Gibt das nächste Zeichen oder EOF zurück.@{PAR} istream &istream::ignore(int n = 1, int delimiter = EOF);@{PAR} Überliest maximal n Zeichen bis zum angegeben Begrenzungszeichen.@{PAR} istream &istream::read(unsigned char *s, int n);@{PAR} istream &istream::read(signed char *s, int n);@{PAR} istream &istream::read(char *, int);@{PAR} Unformatierte Eingabe von n Zeichen in den Buffer, bei Fehlern (z.B. wenn keine n Zeichen gelesen werden können) wird das Flag ios::failbit gesetzt.@{PAR} int istream::gcount();@{PAR} Anzahl der Zeichen, die durch die letzte unformatierte Eingabe gelesen wurden. Formatierte Eingaben können diesen Wert ebenfals in unerwarteter Weise verändern.@{PAR} int istream::peek();@{PAR} Liefert EOF, falls istream::ipfx(1) ebenfalls EOF liefert, sonst das nächste Zeichen im stream. Dieses Zeichen wird allerdings wieder in den stream zurückgestellt.@{PAR} istream &istream::putback(char c); Stellt das zuletzte gelesene Zeichen in den stream zurück. Das Zeichen c muß mit diesem Zeichen übereinstimmen, EOF kann nicht zurückgestellt werden. ios::badbit wird im Fehlerfall gesetzt, z.B. wenn der stream keine Zurückstellung erlaubt. Die Klasse ifstream erlaubt die Zurückstellung eines Zeichens.@{PAR} int istream::sync();@{PAR} Flusht den gebundenen Streampuffer und liefert das gleiche Ergebnis wie die Methode streambuf::sync().@{PAR} istream &istream::seekg(streampos);@{PAR} Setzt den Lesezeiger des streams auf die angegebene Position, die irgendwann zuvor durch istream::tellg() ermittelt wurde.@{PAR} istream &istream::seekg(streamoff, ios::seek_dir);@{PAR} Setzt den Lesezeiger des streams auf den angegebenen Offset, in Abhängigkeit der relativen Startposition der Suche.@{PAR} streampos istream::tellg();@{PAR} Liefert die aktuelle Leseposition des streams, diese Position muß durch die Benutzung der streampuffer nicht mit der physikalischen Leseposition des streams (z.B. einer Datei) übereinstimmen.@{PAR} @{SEE}Siehe auch@{USEE} @{" ios " LINK "ios"}, @{" iostream " LINK "iostream"}, @{" ifstream " LINK "ifstream"}, @{" ostream " LINK "ostream"}@{PAR} @ENDNODE @NODE ostream "ostream" @{FUNC}ostream@{UFUNC} Eine Streamklasse zur Ausgabe.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} class ostream : virtual public ios {@{PAR} public:@{PAR} ostream(streambuf *b);@{PAR} virtual ~ostream();@{PAR} public:@{PAR} int opfx();@{PAR} void osfx();@{PAR} ostream &operator <<(signed char c);@{PAR} ostream &operator <<(unsigned char c);@{PAR} ostream &operator <<(char);@{PAR} ostream &operator <<(const unsigned char *s);@{PAR} ostream &operator <<(const signed char *s);@{PAR} ostream &operator <<(const char *);@{PAR} ostream &operator <<(short i);@{PAR} ostream &operator <<(unsigned short i);@{PAR} ostream &operator <<(int i);@{PAR} ostream &operator <<(unsigned int i);@{PAR} ostream &operator <<(long);@{PAR} ostream &operator <<(unsigned long);@{PAR} ostream &operator <<(float);@{PAR} ostream &operator <<(double);@{PAR} ostream &operator <<(void *);@{PAR} ostream &operator <<(streambuf *);@{PAR} ostream &operator <<(ostream &(*f)(ostream &));@{PAR} ostream &operator <<(ios &(*f)(ios &));@{PAR} ostream &put(char c);@{PAR} ostream &write(const signed char *s, int n);@{PAR} ostream &write(const unsigned char *s, int n);@{PAR} ostream &write(const char *s, int n);@{PAR} ostream &flush();@{PAR} streampos tellp();@{PAR} ostream &seekp(streampos, ios::seek_dir = ios::beg);@{PAR} ostream &seekp(streamoff, ios::seek_dir);@{PAR} protected:@{PAR} ostream();@{PAR} };@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Die Klasse ostream bildet die Basisklasse für formatierte und unformatierte Ausgabe.@{PAR} @{MTHD}Konstruktoren@{UMTHD} ostream::ostream(streambuf *);@{PAR} Initialisiert die Streamklasse und bindet den Puffer.@{PAR} @{MTHD}Methoden@{UMTHD} int ostream::opfx();@{PAR} Erledigt alle Aufgaben vor einer formatierten Ausgabe. Liefert EOF im Falle eines Fehlers oder falls schon zuvor ein Fehler aufgetreten war.@{PAR} void ostream::osfx();@{PAR} Erledigt alle Ausgaben nach einer formatierten Ausgabe.@{PAR} ostream &ostream::operator <<(signed char c);@{PAR} ostream &osream::operator <<(unsigned char c);@{PAR} ostream &ostream::operator <<(char);@{PAR} Ausgabe eines einzelnen Zeichens.@{PAR} ostream &ostream::operator <<(const unsigned char *s);@{PAR} ostream &ostream::operator <<(const signed char *s);@{PAR} ostream &ostream::operator <<(const char *);@{PAR} Ausgabe eines Strings.@{PAR} ostream &ostream::operator <<(short i);@{PAR} ostream &ostream::operator <<(unsigned short i);@{PAR} ostream &ostream::operator <<(int i);@{PAR} ostream &ostream::operator <<(unsigned int i);@{PAR} ostream &ostream::operator <<(long);@{PAR} ostream &ostream::operator <<(unsigned long);@{PAR} Ausgabe einer Zahl, je nach Typ mit oder ohne Vorzeichen.@{PAR} ostream &ostream::operator <<(float);@{PAR} ostream &ostream::operator <<(double);@{PAR} Ausgabe einer Fließkommazahl.@{PAR} ostream &ostream::operator <<(void *);@{PAR} Ausgabe eines Pointers als Hexadezimalwert.@{PAR} ostream &ostream::operator <<(ostream &(*f)(ostream &));@{PAR} ostream &ostream::operator <<(ios &(*f)(ios &));@{PAR} Erlaubt die Benutzung von Ausgabemanipulatoren, dazu wird die angegebene Funktion aufgerufen, als Parameter wird das ostream Objekt selbst angegeben.@{PAR} ostream &ostream::put(char c);@{PAR} Unformatierte Ausgabe eines Zeichens.@{PAR} ostream &ostream::write(const signed char *s, int n);@{PAR} ostream &ostream::write(const unsigned char *s, int n);@{PAR} ostream &ostream::write(const char *s, int n);@{PAR} Unformatierte Ausgabe von genau n Zeichen, das Nullzeichen wird nicht gesondert behandelt.@{PAR} ostream &ostream::flush();@{PAR} Flusht den Ausgabestream, alle Zeichen die sich noch im Puffer liegen, werden physikalisch ausgegeben. Nur diese Funktion bewirkt die physikalische Ausgabe der Pufferdaten (abgesehen vom Fall, daß der Puffer überläuft), das Zeichen "\n" (neue Zeile) hat diese Wirkung auch auf cout oder anderen Konsoledateien nicht.@{PAR} streampos ostream::tellp();@{PAR} Liefert die Position des Ausgabezeigers, diese muß nicht unbedingt mit der physikalischen Position des streams (z.B. einer Datei) übereinstimmen.@{PAR} ostream &ostream::seekp(streampos, ios::seek_dir = ios::beg);@{PAR} Setzt den Ausgabezeiger reltiv zur angegeben Startposition der Suche neu.@{PAR} ostream &seekp(streamoff, ios::seek_dir);@{PAR} Setzt den Ausgabezeiger auf die Position, die irgendwann vorher durch die Methode ostream::tellp() ermittelt wurde.@{PAR} @{SEE}Siehe auch@{USEE} @{" ios " LINK "ios"}, @{" iostream " LINK "iostream"}, @{" ofstream " LINK "ofstream"}, @{" istream " LINK "istream"}@{PAR} @ENDNODE @NODE filebuf "filebuf" @{FUNC}filebuf@{UFUNC} Der Dateipuffer für die Klassen fstream, ifstream und ofstream.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} class filebuf : public streambuf {@{PAR} public:@{PAR} filebuf();@{PAR} virtual ~filebuf();@{PAR} int is_open();@{PAR} filebuf *open(const char *, int);@{PAR} filebuf *close();@{PAR} virtual streampos seekoff(streamoff, ios::seek_dir, int = ios::in|ios::out);@{PAR} virtual streampos seekpos(streampos, int = ios::in|ios::out);@{PAR} virtual streambuf *setbuf(char *, size_t);@{PAR} virtual int sync();@{PAR} protected:@{PAR} virtual int doallocate();@{PAR} virtual int overflow(int = EOF);@{PAR} virtual int underflow();@{PAR} virtual int xsputn(const char *, int);@{PAR} virtual int xsgetn(char *, int);@{PAR} virtual int pbackfail(int);@{PAR} };@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Diese Klasse stellt einen Zeichenpuffer für Ein- und Ausgabe auf Dateien zur Verfügung. Der Positionszeiger für Eingabe und Ausgabe ist immer identisch, der Wechsel zwischen Ein- und Ausgabe ist jederzeit möglich.@{PAR} @{MTHD}Konstruktoren@{UMTHD} filebuf::filebuf();@{PAR} Initialisiert den Dateipuffer, es wird keine Datei geöffnet.@{PAR} @{MTHD}Destruktoren@{UMTHD} virtual ~filebuf();@{PAR} Schließt eine eventuell offene Datei.@{PAR} @{MTHD}Methoden@{UMTHD} int filebuf::is_open();@{PAR} Liefert 1, falls eine Datei geöffnet ist, 0 sonst.@{PAR} filebuf *filebuf::open(const char *, int);@{PAR} Öffnet eine Datei mit einem Modus der ios::open_mode Flags.@{PAR} filebuf *filebuf::close();@{PAR} Schließt die Datei.@{PAR} streampos filebuf::seekoff(streamoff, ios::seek_dir, int = ios::in|ios::out);@{PAR} Setzt den Lese-/Schreibzeiger auf eine neue Position.@{PAR} streampos filepos::seekpos(streampos, int = ios::in|ios::out);@{PAR} Setzt den Lese-/Schreibzeiger auf eine neue Position.@{PAR} streambuf *filebuf::setbuf(char *, size_t);@{PAR} Setzt falls möglich den Dateipuffer auf den angegeben Puffer mit der angegeben Größe. Liefert NULL, falls der Puffer nicht akzeptiert werden konnte.@{PAR} int filebuf::sync();@{PAR} Synchronisiert den Puffer und die Datei. Stehen Zeichen zur Ausgabe im Puffer, so werden diese geschrieben, stehen noch Eingaben im Puffer, so wird der Lese-/Schreibzeiger der Datei auf diese Position korrigiert. Der Puffer wird in jedem Fall gelöscht.@{PAR} @{SEE}Siehe auch@{USEE} @{" streambuf " LINK "streambuf"}, @{" fstream " LINK "fstream"}, @{" ifstream " LINK "ifstream"}, @{" ofstream " LINK "ofstream"}@{PAR} @ENDNODE @NODE streambuf "streambuf" @{FUNC}streambuf@{UFUNC} Eine Basisklasse für Streampuffer.@{PAR} @{SYN}Übersicht@{USYN} #include @{PAR} class streambuf {@{PAR} protected:@{PAR} streambuf();@{PAR} streambuf(char *, int);@{PAR} public:@{PAR} virtual ~streambuf();@{PAR} int in_avail();@{PAR} int out_waiting();@{PAR} int sbumpc();@{PAR} int sgetc();@{PAR} int sgetn(char *, int);@{PAR} int snextc();@{PAR} void stossc();@{PAR} int sputbackc(char c);@{PAR} int sputc(int c);@{PAR} int sputn(const char *,int);@{PAR} virtual int sync();@{PAR} virtual streampos seekoff(streamoff, ios::seek_dir, int = ios::in|ios::out);@{PAR} virtual streampos seekpos(streampos p, int mode = ios::in|ios::out);@{PAR} virtual streambuf *setbuf(char *, size_t);@{PAR} protected:@{PAR} void setbuffer(char *, unsigned long n, int dynamic = 0);@{PAR} int allocate();@{PAR} int unbuffered();@{PAR} void unbuffered(int i);@{PAR} virtual int overflow(int = EOF);@{PAR} virtual int underflow();@{PAR} virtual int xsputn(const char *,int);@{PAR} virtual int xsgetn(char *,int);@{PAR} virtual int pback fail(int);@{PAR} virtual int doallocate();@{PAR} void pbump(int i);@{PAR} void gbump(int i);@{PAR} };@{PAR} @{PORT}Portabilität@{UPORT} AT&T Release 2 streams library@{PAR} @{XPL}Erklärung@{UXPL} Diese Klasse bildet die Basisklasse für Streampuffer. Dabei ist die Implementation der Datenstruktur des Zeichenpuffers mit allen Zeigern schon in dieser Klasse festgelegt, die abgeleiteten Klassen müssen nur noch die Funktionen zur Verfügung stellen, die bei Über- oder Unterlauf des Puffers benötigt werden. Durch diese frühe Implementation sind im Normalfall, d.h. wenn kein Über- oder Unterlauf passiert, die @{MTHD}Methoden@{UMTHD} zum Lesen oder Schreiben eines Zeichens sehr schnell.@{PAR} @{MTHD}Konstruktoren@{UMTHD} streambuf::streambuf();@{PAR} Initialisiert den Puffer zum Lesen und Schreiben.@{PAR} streambuf::streambuf(char *, int);@{PAR} Initialisiert den Puffer zum Lesen und Schreiben mit einem vorgegebenen Speicherbereich fester Größe.@{PAR} @{MTHD}Destruktoren@{UMTHD} streambuf::~streambuf();@{PAR} Synchronisiert den Puffer mit dem physikalischen Ausgabemedium.@{PAR} @{MTHD}Methoden@{UMTHD} int streambuf::in_avail();@{PAR} Liefert die Anzahl der Zeichen im Puffer, die noch nicht gelesen wurden.@{PAR} int streambuf::out_waiting();@{PAR} Liefert die Anzahl der Zeichen im Puffer, die noch nicht in das physikalische Ausgabemedium geschrieben wurden.@{PAR} int streambuf::sbumpc();@{PAR} Liest ein Zeichen oder EOF im Fehlerfall oder am Ende der Datei. Setzt den Lesezeiger eins weiter.@{PAR} int streambuf::sgetc();@{PAR} Liefert ein Zeichen oder EOF. Der Lesezeiger wird nicht bewegt.@{PAR} int streambuf::sgetn(char *, int n);@{PAR} Schreibt maximal n Zeichen in das char Feld und liefert die tatsächliche Anzahl gelesener Zeichen.@{PAR} int streambuf::snextc();@{PAR} Setzt den Lesezeiger eins weiter und liefert das damit erreichte Zeichen.@{PAR} void streambuf::stossc();@{PAR} Setzt den Lesezeiger eins weiter.@{PAR} int streambuf::sputbackc(char c);@{PAR} Stellt ein Zeichen in den Puffer bzw. den stream zurück. Das Zeichen c muß mit dem entsprechend vorher gelesenen Zeichen übereinstimmen, dabei können auch mehrere Zeichen nacheinander zurückgestellt werden (wobei das zuletzt gelesene Zeichen zuerst zurückgestellt werden muß). Liefert EOF, falls die Zurückstellung nicht funktioniert, die meisten streams erlauben wenigstens die Zurückstellung zumindest eines Zeichens.@{PAR} int streambuf::sputc(int c);@{PAR} Schreibt ein Zeichen und setzt den Scxhreibzeiger dabei eins weiter. Liefert c im Erfolgsfall, EOF im Fehlerfall.@{PAR} int streambuf::sputn(const char *,int n);@{PAR} Schreibt bis zu n Zeichen aus dem char Feld, liefert die Anzahl tatsächlich geschriebener Zeichen. Eine kleiner Zahl als n läßt für die meisten streams auch auf einen Fehler schließen.@{PAR} int streambuf::sync();@{PAR} Synchronisiert Puffer und das physikalische Ausgabemedium.@{PAR} streampos streambuf::seekoff(streamoff, ios::seek_dir, int = ios::in|ios::out);@{PAR} Setzt den Schreib- oder Lesezeiger (oder beide) auf die angegebene Position, relativ zur angegebenen Startposition. Manche streams identifizieren den Schreib- und den Lesezeiger, dann ist der Modus egal.@{PAR} streampos streambuf::seekpos(streampos p, int mode = ios::in|ios::out);@{PAR} Setzt den Schreib- oder Lesezeiger (oder beide) auf die angegebene Position. Manche stream identifizieren den Schreib- und den Lesezeiger, dann ist der Modus egal.@{PAR} streambuf *streambuf::setbuf(char *, size_t);@{PAR} Setzt den Speicherbereich für den Puffer auf die angegebene Adresse und Größe. Im Eroflgsfall liefert diese Methode den Pointer auf das streambuf Objekt, sonst NULL.@{PAR} void streambuf::setbuffer(char *, unsigned long n, int dynamic = 0);@{PAR} Setzt den Speicherbereich des Puffers und initialisiert ihn als leeren Puffer. Der Parameter dynamic muß mit 1 angegeben werden, wenn der Speicherbereich mit new alloziiert wurde und mit delete automatisch freigegeben werden soll.@{PAR} int streambuf::allocate();@{PAR} Allokiert bei Bedarf einen Puffer vermittels streambuf::doallocate().@{PAR} int streambuf::unbuffered();@{PAR} Liefert 1, falls der stream ungepuffert ist, sonst 0.@{PAR} void streambuf::unbuffered(int i);@{PAR} Falls i gleich 1, wird der stream in den ungepufferten Modus geschaltet. Dieser Modus ist für fast alle streams viel langsamer als der gepufferte Modus und sollte möglichst vermieden werden.@{PAR} int streambuf::overflow(int = EOF);@{PAR} Diese Methode wird aufgerufen, wenn der Puffer zum Schreiben voll ist. Je nach konkreten stream muß dann dieser Puffer in das Ausgabemedium übertragen werden und das übergebene Zeichen in den Puffer eingetragen werden. Im ungepufferten Modus wird für jedes Zeichen diese Methode aufgerufen und muß das Zeichen direkt in das Ausgabemedium übertragen.@{PAR} int streambuf::underflow();@{PAR} Diese Methode wird aufgerufen, wenn der Puffer zum Lesen leer ist und neu gefüllt werden muß. Diese Methode liefert dann das erste gelesene Zeichen. Im ungepufferten Modus muß jedes Zeichen einzeln aus dem Eingabemedium gelesen werden.@{PAR} int streambuf::xsputn(const char *,int n);@{PAR} Diese Methode wird benutzt, wenn ein ganzer char Feld der Länge n nicht auf einen Satz in den Puffer kopiert werden konnte und nun stückweise ausgegeben werden muß.@{PAR} int streambuf::xsgetn(char *,int);@{PAR} Diese Methode wird aufgerufen, wenn der Puffer nicht genügend Zeichen für das ganze char Feld enthält und nun stückweise gelesen werden muß.@{PAR} int streambuf::pbackfail(int);@{PAR} Diese Methode wird aufgerufen, wenn beim Zurückstellen eines Zeichens in den Puffer dieser das Zeichen nicht aufnehmen kann (z.B. weil der Puffer noch voll ist oder zum Schreiben gefüllt). Diese Methode liefert das Zeichen im Erfolgsfall, EOF im Fehlerfall.@{PAR} int streambuf::doallocate();@{PAR} Diese Methode reserviert einen Speicherbereich mittels new als Puffer.@{PAR} @{SEE}Siehe auch@{USEE} @{" filebuf " LINK "filebuf"}@{PAR} @ENDNODE @NODE AusgabeFormatString "Ausgabe-Format-String" @{HEADER}Ausgabe-Format-String zur formatierten Ausgabe@{UHEADER} Ein Ausgabe-Format-String setzt sich aus Formatkommandos und Ausgabezeichen zusammen. Die Formatkommandos bestimmen den Typ der Parameter der Ausgabefunktion und die Art der Konvertierung und Ausgabe. Alle Zeichen, die kein Formatkommando sind, d.h. nicht mit dem Zeichen "%" beginnen sind Ausgabezeichen und werden unverändert ausgegeben.@{PAR} Der Aufbau eines Formatkommandos:@{PAR} %[flags][width[.limit]][size]type@{PAR} Die Bestandteile in eckigen Klammern sind optional.@{PAR} @{ENUM}flags@{UENUM}@{PAR} '-' zur Linksjustierung;@{PAR} '+' zur Ausgabe auch eines positiven Vorzeichens bei Zahlen;@{PAR} '0' zur Ausgabe führender Nullen bei Zahlen;@{PAR} '#' zum Ausgabe von '0x' bei hexadezimalen Zahlen und '0' bei oktalen Zahlen sowie abschließender Nullen, falls für type 'g' oder 'G' angegeben wird.@{PAR} @{ENUM}width@{UENUM}@{PAR} Feldbreite als dezimale Ziffernfolge oder '*', in diesem Fall wird die Feldbreite als nächstes Argument des Typs int übergeben. Die Feldbreite ist immer ein minimaler Wert, zu lange Ausgaben werden nicht beschnitten.@{PAR} @{ENUM}limit@{UENUM}@{PAR} Die Genauigkeit als dezimale Ziffernfolge oder '*', in diesem Fall wird die Genauigkeit als nächstes Argument des Typs int übergeben. Der Wert beschreibt die maximale Anzahl von Zeichen bei Ausgabe einer Zeichenkette, die minimale Anzahl von Ziffern einer ganzzahligen Ausgabe oder die Anzahl der Nachkommastellen einer Gleitkommaausgabe.@{PAR} @{ENUM}size@{UENUM}@{PAR} Längenangabe des Arguments:@{PAR} 'h' für ein Argument des Typs short int oder unsigned short int;@{PAR} 'l' für ein Argument des Typs long int oder unsigned long int;@{PAR} @{ENUM}type@{UENUM}@{PAR} Typangabe des Arguments:@{PAR} 'd' oder 'i' zur Ausgabe einer vorzeichenbehafteten Dezimalzahl, das zugehörige Argument ist vom Typ int@{PAR} 'o' zur Ausgabe einer vorzeichenlosen Oktalzahl, das zugehörige Argument ist vom Typ int oder unsigned int@{PAR} 'x' zur Ausgabe einer vorzeichenlosen Hexadezimalzahl mit Kleinbuchstaben, das zugehörige Argument ist vom Typ int oder unsigned int@{PAR} 'X' zur Ausgabe einer vorzeichenlosen Hexadezimalzahl mit Großbuchstaben, das zugehörige Argument ist vom Typ int oder unsigned int@{PAR} 'u' zur Ausgabe einer vorzeichenlosen Dezimalzahl, das zugehörige Argument ist vom Typ unsigned int@{PAR} 'c' zur Ausgabe eines Zeichens, das zugehörige Argument ist vom Typ int und wird in unsigned char konvertiert@{PAR} 's' zur Ausgabe einer Zeichenkette, die mit einem Nullzeichen abgeschlossen ist, das zugehörige Argument ist vom Typ char *@{PAR} 'f' zur Ausgabe einer Fließkommazahl in nichtexponentieller Darstellung, das zugehörige Argument ist vom Typ double@{PAR} 'e' zur Ausgabe einer Fließkommazahl in exponentieller Darstellung mit kleinem 'e' als Exponentzeichen, das zugehörige Argument ist vom Typ double@{PAR} 'E' zur Ausgabe einer Fließkommazahl in exponentieller Darstellung mit großem 'E' als Exponentzeichen, das zugehörige Argument ist vom Typ double@{PAR} 'g' zur Ausgabe einer Fließkommazahl je nach Exponent in nichtexponentieller oder exponentieller Darstellung mit kleinem "e" als Exponentzeichen, das zugehörige Argument ist vom Typ double@{PAR} 'G' zur Ausgabe einer Fließkommazahl je nach Exponent in nichtexponentieller oder exponentieller Darstellung mit großem "E" als Exponentzeichen, das zugehörige Argument ist vom Typ double@{PAR} 'p' zur Ausgabe einer hexadezimalen Speicheradresse, das zugehörige Argument ist vom Typ void *;@{PAR} 'n' zur Speicherung der Anzahl der bisher von diesem Funktionsaufruf ausgegebenen Zeichen in der Variablen, auf die das Argument vom Typ int * zeigt, es erfolgt keine Ausgabe@{PAR} '%' zur Ausgabe eines Prozentzeichens@{PAR} Alle anderen Typausgaben führen zu undefinierten Ausgaben.@{PAR} @ENDNODE @NODE EingabeFormatString "Eingabe-Format-String" @{HEADER}Eingabe-Format-String zur formatierten Eingabe@{UHEADER} Ein Eingabe-Format-String setzt sich aus Formatkommandos und Eingabezeichen zusammen. Die Formatkommandos bestimmen den Typ der Parameter der Eingabefunktion und die Art der Konvertierung und Eingabe. Alle Zeichen, die kein Formatkommando sind, d.h. nicht mit dem Zeichen "%" beginnen und keine Trennzeichen, d.h. Leerezeichen, Tabulatoren und Zeilenvorschübe sind sind Eingabezeichen und werden unverändert in der Eingabe erwartet.@{PAR} Der Aufbau eines Formatkommandos:@{PAR} %[width][size]type Bestandteile in eckigen Klammern sind optional.@{PAR} @{ENUM}width@{UENUM}@{PAR} Die Anzahl der zu lesenden Zeichen als dezimale Ziffernfolge oder '*', in diesem Fall werden die Zeichen zwar gelesen, aber nicht in das nächste Argument übertragen.@{PAR} @{ENUM}size@{UENUM}@{PAR} Längenangabe des Arguments:@{PAR} 'h' für ein Argument des Typs short int oder unsigned short int@{PAR} 'l' für ein Argument des Typs long int oder unsigned long int@{PAR} @{ENUM}type@{UENUM}@{PAR} Typangabe des Arguments:@{PAR} 'd' zur Eingabe einer vorzeichenbehafteten dezimalen Ganzzahl, das zugehörige Argument ist vom Typ int *@{PAR} 'i' zur Eingabe einer vorzeichenbehafteten Dezimalzahl, Oktalzahl (bei führender '0') oder Hexadezimalzahl (bei führendem '0x' oder '0X'), das zugehörige Argument ist vom Typ int *@{PAR} 'o' zur Eingabe einer Oktalzahl, das zugehörige Argument ist vom Typ int *@{PAR} 'x' zur Eingabe einer Hexadezimalzahl mit oder ohne '0x', das zugehörige Argument ist vom Typ int oder unsigned int@{PAR} 'c' zur Eingabe von "width" Zeichen, wobei Leerzeichen und Zeilentrenner nicht überlesen werden und kein Nullzeichen angehängt wird, das zugehörige Argument ist vom Typ char *@{PAR} 's' zur Eingabe einer Zeichenkette, wobei führende Leerzeichen und Zeilentrenner überlesen werden und ein Nullzeichen angehängt wird, das zugehörigen Argument ist vom Typ char *@{PAR} 'e', 'f' und 'g' zur Eingabe einer Fließkommazahl in beliebiger Darstellung, das zugehörige Argument ist vom Typ float *@{PAR} 'p' zur Eingabe einer hexadezimalen Speicheradresse, das zugehörige Argument ist vom Typ int *@{PAR} 'n' zur Speicherung der Anzahl der bisher von diesem Funktionsaufruf gelesenen Zeichen in der Variablen, auf die das Argument vom Typ int * zeigt, es wird kein Zeichen gelesen.@{PAR} '[...]' zur Eingabe einer Zeichenkette, die nur aus den in den eckigen Klammern angegebenen Zeichen besteht, wobei ein Nullzeichen angehängt wird, das zugehörigen Argument ist vom Typ char *@{PAR} '[^...]' zur Eingabe einer Zeichenkette, die nur aus Zeichen besteht, die nicht in den eckigen Klammern angegebenen sind, wobei ein Nullzeichen angehängt wird; das zugehörigen Argument ist vom Typ char *@{PAR} '%%' zur Eingabe eines Prozentzeichens@{PAR} Alle anderen Typangaben führen zu undefinierten Eingaben.@{PAR} @ENDNODE @NODE ZeitFormatString "Zeit-Format-String" @{HEADER}Zeit-Format-String zur Konvertierung einer Zeitangabe.@{UHEADER} Ein Zeit-Format-String setzt sich aus Formatkommandos und Ausgabezeichen zusammen. Die Formatkommandos bestimmen den Typ der Parameter der Ausgabefunktion und die Art der Konvertierung und Ausgabe. Alle Zeichen, die kein Formatkommando sind, d.h. nicht mit dem Zeichen "%" beginnen sind Ausgabezeichen und werden unverändert ausgegeben.@{PAR} Der Aufbau eines Formatkommandos:@{PAR} %type@{PAR} @{ENUM}type@{UENUM}@{PAR} 'a' für den abgekürzten Namen des Wochentages (Mon, Tue, ...)@{PAR} 'A' für den vollständigen Namen des Wochentages@{PAR} 'b' für den abgekürzten Namen des Monats (Jan, Feb, ...)@{PAR} 'B' für den vollständigen Namen des Monats@{PAR} 'c' für die Kurzdarstellung von Datum und Uhrzeit@{PAR} 'd' für die Nummer des Tages des Monats im Bereich von 1 bis 31@{PAR} 'H' für die amerikanische Stundendarstellung im Bereich von 1 bis 12@{PAR} 'I' für die europäische Stundendarstellung im Bereich von 0 bis 23@{PAR} 'j' für die Nummer des Tages im Jahr im Bereich von 1 bis 366@{PAR} 'm' für die Nummer des Monats im Bereich von 1 bis 12@{PAR} 'M' für die Anzahl der Minuten im Bereich von 0 bis 59@{PAR} 'p' für die Tageshälfte ("a.m." oder "p.m.")@{PAR} 'S' für die Anzahl von Sekunden im Bereich von 0 bis 61@{PAR} 'U' für die Nummer der Woche im Jahr im Bereich von 0 bis 53 (Sonntag ist erster Wochentag)@{PAR} 'w' für die Nummer des Wochentages im Bereich von 0 bis 6 (Sonntag ist 0)@{PAR} 'W' für die Nummer der Woche im Jahr im Bereich von 0 bis 53 (Montag ist erster Wochentag)@{PAR} 'x' für die Kurzdarstellung des Datums@{PAR} 'X' für die Uhrzeit@{PAR} 'y' für die Jahreszahl ohne Jahrhundert@{PAR} 'Y' für die vollständige Jahreszahl mit Jahrhundert@{PAR} 'Z' für den Namen der Zeitzone@{PAR} '%' für ein Prozentzeichen@{PAR} Alle anderen Typausgaben führen zu undefinierten Ausgaben.@{PAR} @ENDNODE @NODE Index "Alphabetischer Index" @{LETTER}A@{ULETTER}@{PAR} @{" abort " LINK "abort"} @{" abs " LINK "abs"} @{" acos " LINK "acos"}@{PAR} @{" asctime " LINK "asctime"} @{" asin " LINK "asin"} @{" assert " LINK "assert"}@{PAR} @{" atan " LINK "atan"} @{" atan2 " LINK "atan2"} @{" atexit " LINK "atexit"}@{PAR} @{" atof " LINK "atof"} @{" atoi " LINK "atoi"} @{" atol " LINK "atol"}@{PAR} @{LETTER}B@{ULETTER}@{PAR} @{" bsearch " LINK "bsearch"}@{PAR} @{LETTER}C@{ULETTER}@{PAR} @{" calloc " LINK "calloc"} @{" ceil " LINK "ceil"} @{" cerr " LINK "cerr"}@{PAR} @{" cin " LINK "cin"} @{" clearerr " LINK "clearerr"} @{" clock " LINK "clock"}@{PAR} @{" clog " LINK "clog"} @{" cos " LINK "cos"} @{" cosh " LINK "cosh"}@{PAR} @{" cout " LINK "cout"} @{" ctime " LINK "ctime"}@{PAR} @{LETTER}D@{ULETTER}@{PAR} @{" difftime " LINK "difftime"} @{" div " LINK "div"}@{PAR} @{LETTER}E@{ULETTER}@{PAR} @{" exit " LINK "exit"} @{" exp " LINK "exp"}@{PAR} @{LETTER}F@{ULETTER}@{PAR} @{" fabs " LINK "fabs"} @{" fclose " LINK "fclose"} @{" feof " LINK "feof"}@{PAR} @{" ferror " LINK "ferror"} @{" fflush " LINK "fflush"} @{" fgetc " LINK "fgetc"}@{PAR} @{" fgetpos " LINK "fgetpos"} @{" fgets " LINK "fgets"} @{" filebuf " LINK "filebuf"}@{PAR} @{" floor " LINK "floor"} @{" fmod " LINK "fmod"} @{" fopen " LINK "fopen"}@{PAR} @{" fprintf " LINK "fprintf"} @{" fp utc " LINK "fputc"} @{" fputs " LINK "fputs"}@{PAR} @{" fread " LINK "fread"} @{" free " LINK "free"} @{" freopen " LINK "freopen"}@{PAR} @{" frexp " LINK "frexp"} @{" fscanf " LINK "fscanf"} @{" fseek " LINK "fseek"}@{PAR} @{" fsetpos " LINK "fsetpos"} @{" fstream " LINK "fstream"} @{" ftell " LINK "ftell"}@{PAR} @{" fwrite " LINK "fwrite"}@{PAR} @{LETTER}G@{ULETTER}@{PAR} @{" getc " LINK "getc"} @{" getchar " LINK "getchar"} @{" getenv " LINK "getenv"}@{PAR} @{" gets " LINK "gets"} @{" gmtime " LINK "gmtime"}@{PAR} @{LETTER}I@{ULETTER}@{PAR} @{" ifstream " LINK "ifstream"} @{" ios " LINK "ios"} @{" iostream " LINK "iostream"}@{PAR} @{" isalnum " LINK "isalnum"} @{" isalpha " LINK "isalpha"} @{" iscntrl " LINK "iscntrl"}@{PAR} @{" isdigit " LINK "isdigit"} @{" isgraph " LINK "isgraph"} @{" islower " LINK "islower"}@{PAR} @{" isprint " LINK "isprint"} @{" ispunct " LINK "ispunct"} @{" isspace " LINK "isspace"}@{PAR} @{" istream " LINK "istream"} @{" isupper " LINK "isupper"} @{" isxdigit " LINK "isxdigit"}@{PAR} @{LETTER}L@{ULETTER}@{PAR} @{" labs " LINK "labs"} @{" ldexp " LINK "ldexp"} @{" ldiv " LINK "ldiv"}@{PAR} @{" localtime " LINK "localtime"} @{" log " LINK "log"} @{" log10 " LINK "log10"}@{PAR} @{" longjmp " LINK "longjmp"}@{PAR} @{LETTER}M@{ULETTER}@{PAR} @{" malloc " LINK "malloc"} @{" memchr " LINK "memchr"} @{" memcmp " LINK "memcmp"}@{PAR} @{" memcpy " LINK "memcpy"} @{" memmove " LINK "memmove"} @{" memset " LINK "memset"}@{PAR} @{" mktime " LINK "mktime"} @{" modf " LINK "modf"}@{PAR} @{LETTER}O@{ULETTER}@{PAR} @{" offsetof " LINK "offsetof"} @{" ofstream " LINK "ofstream"} @{" ostream " LINK "ostream"}@{PAR} @{LETTER}P@{ULETTER}@{PAR} @{" perror " LINK "perror"} @{" pow " LINK "pow"} @{" printf " LINK "printf"}@{PAR} @{" putc " LINK "putc"} @{" putchar " LINK "putchar"} @{" puts " LINK "puts"}@{PAR} @{LETTER}Q@{ULETTER}@{PAR} @{" qsort " LINK "qsort"}@{PAR} @{LETTER}R@{ULETTER}@{PAR} @{" raise " LINK "raise"} @{" rand " LINK "rand"} @{" realloc " LINK "realloc"}@{PAR} @{" remove " LINK "remove"} @{" rename " LINK "rename"} @{" rewind " LINK "rewind"}@{PAR} @{LETTER}S@{ULETTER}@{PAR} @{" scanf " LINK "scanf"} @{" setbuf " LINK "setbuf"} @{" setjmp " LINK "setjmp"}@{PAR} @{" setvbuf " LINK "setvbuf"} @{" signal " LINK "signal"} @{" sin " LINK "sin"}@{PAR} @{" sinh " LINK "sinh"} @{" sprintf " LINK "sprintf"} @{" sqrt " LINK "sqrt"}@{PAR} @{" srand " LINK "srand"} @{" sscanf " LINK "sscanf"} @{" strcat " LINK "strcat"}@{PAR} @{" strchr " LINK "strchr"} @{" strcmp " LINK "strcmp"} @{" strcpy " LINK "strcpy"}@{PAR} @{" strcspn " LINK "strcspn"} @{" streambuf " LINK "streambuf"} @{" strerror " LINK "strerror"}@{PAR} @{" strftime " LINK "strftime"} @{" stricmp " LINK "stricmp"} @{" strlen " LINK "strlen"}@{PAR} @{" strncat " LINK "strncat"} @{" strncmp " LINK "strncmp"} @{" strncpy " LINK "strncpy"}@{PAR} @{" strpbrk " LINK "strpbrk"} @{" strrchr " LINK "strrchr"} @{" strspn " LINK "strspn"}@{PAR} @{" strstr " LINK "strstr"} @{" strtod " LINK "strtod"} @{" strtok " LINK "strtok"}@{PAR} @{" strtol " LINK "strtol"} @{" strtoul " LINK "strtoul"} @{" system " LINK "system"}@{PAR} @{LETTER}T@{ULETTER}@{PAR} @{" tan " LINK "tan"} @{" tanh " LINK "tanh"} @{" time " LINK "time"}@{PAR} @{" tmpfile " LINK "tmpfile"} @{" tmpnam " LINK "tmpnam"} @{" tolower " LINK "tolower"}@{PAR} @{" toupper " LINK "toupper"}@{PAR} @{LETTER}U@{ULETTER}@{PAR} @{" ungetc " LINK "ungetc"}@{PAR} @{LETTER}V@{ULETTER}@{PAR} @{" va_arg " LINK "va_arg"} @{" va_end " LINK "va_end"} @{" va_start " LINK "va_start"}@{PAR} @{" vfprintf " LINK "vfprintf"} @{" vprintf " LINK "vprintf"} @{" vsprintf " LINK "vsprintf"}@{PAR} @ENDNODE