Algorithmen & Datenstrukturen
Programmieren 1


von Prof. Jürgen Plate

Die Standard-Bibliotheks-Funktionen

abort
abs
acos
asctime
asin
assert
atan
atan2
atexit
atof
atoi
atol
bsearch
calloc
ceil
clearerr
clock
closedir
chdir
cos
cosh
ctime
difftime
div
exit
exp
fabs
fclose
feof
ferror
fflush
fgetc
fgetpos
fgets
floor
fmod
fopen
fprintf
fputc
fputs
fread
free
freopen
frexp
fscanf
fseek
fsetpos
ftell
fwrite
getc
getchar
getenv
gets
gmtime
isalnum
isalpha
iscntrl
isdigit
isgraph
islower
isprint
ispunct
isspace
isupper
isxdigit
labs
ldexp
ldiv
localtime
log
log10
longjmp
malloc
memchr
memcmp
memcpy
memmove
memset
mktime
modf
opendir
perror
popen
pclose
pow
printf
putc
putchar
puts
qsort
raise
rand
readdir
realloc
remove
rename
rewind
scanf
seekdir
setbuf
setjmp
setvbuf
signal
sin
sinh
sprintf
sqrt
srand
sscanf
strcat
strchr
strcmp
strcpy
strcspn
strerror
strlen
strncat
strncmp
strncpy
strpbrk
strrchr
strcspn
strstr
strtod
strtok
strtol
strtoul
system
tan
tanh
telldir
time
tmpfile
tmpnam
tolower
toupper
ungetc
va_arg
va_end
va_start
vfprintf
vprintf
vsprintf

abort

Bibliothek: #include <stdlib.h>
Prototyp: void abort(void);
Rückgabewert: keiner
Beschreibung: Gibt die Meldung Abnormal program termination auf der Fehlerausgabe stderr aus und bricht den laufenden Prozess ab (normaler Programmabbruch siehe exit()).
Beispiel:
if (fp= fopen("/etc/passwd","r") == NULL)
  { printf("Datei nicht gefunden!\n"); abort(); }

abs

Bibliothek: #include <stdlib.h>
Prototyp: int abs(int x);
Rückgabewert: Absolutbetrag von x
Beschreibung: Berechnet den Absolutwert des int-Wertes x (siehe auch labs und fabs).
Beispiel:
printf("abs(-8) = %d\n",abs(-8));
/* Ausgabe: abs(-8) = 8 */

acos

Bibliothek: #include <math.h>
Prototyp: double acos(double x);
Rückgabewert: Arcuscosinus von x im Bogenmaß (zwischen 0 und Pi); Im Fehlerfall 0, und gleichzeitig Fehlermeldung auf stderr, Fehlervariable errno = EDOM (domain error)
Beschreibung: Berechnet den Arcuscosinus des Argumentes x (-1 <= x <= +1)
Beispiel:
printf("acos(-1.0) = %6.4f\n",acos(-1.0));
/* Ausgabe: acos(-1.0) = 3.1416 */

asctime

Bibliothek: #include <time.h>
Prototyp: char *asctime(struct tm *systime);
Rückgabewert: Zeiger auf String mit Datum und Uhrzeit (26 Bytes lang)
Beschreibung: Konvertiert Datum und Uhrzeit in einen String. Datum und Uhrzeit sind in der durch systime addressierten Struktur von Type tm abgelegt (wurde zuvor mit localtime oder gmtime angelegt und mit Werten gefüllt). Die Ortszeit-Struktur struct tm hat folgende Elemente:
  • int tm_sec Sekunden nach voller Minute (0-61)
  • int tm_min Minuten nach voller Stunde (0-59)
  • int tm_hour Stunden seit Mitternacht (0-23)
  • int tm_mday Tag im Monat (1-31)
  • int tm_mon Monat nach Januar (0-11)
  • int tm_year Jahr minus 1900
  • int tm_wday Wochentag (0-6, 0=Sonntag)
  • int tm_yday Tag im Jahr nach 1. Januar (0-365)
  • int tm_isdst >0: Sommerzeit, =0: Winterzeit, <0: unbekannt
Beispiel:
struct tm *systime;
time_t sec;
time(&sec);
systime = localtime (&sec);
printf("Datum und Uhrzeit: %s\n",asctime(systime));
/* Ausgabe: Datum und Uhrzeit: Mon Jul 18 9:00:48 2005 */

asin

Bibliothek: #include <math.h>
Prototyp: double asin(double x);
Rückgabewert: Arcussinus von x im Bogenmaß (Wert zwischen -Pi/2 und +Pi/2); Im Fehlerfall 0 und Fehlermeldung auf stderr, Fehlervariable errno = EDOM
Beschreibung: Berechnet den Arcussinus des Argumentes x (-1 <= x <= +1).
Beispiel:
printf("asin(-1.0) = %7.4f",asin(-1.0));
/* Ausgabe: asin(-1.0) = -1.5708 */

assert

Bibliothek: #include <assert.h>
Prototyp: void assert(int expression);
Rückgabewert: keiner
Beschreibung: Das Makro überprüft den Ausdruck expression, um logische Fehler im Programm zu finden. Ist das Ergebnis 0 (Fehler), so wird die Meldung: "Assertion failed: expression, file: name, line: number" ausgegeben. Danach erfolgt Programmabbruch.
Beispiel:
double x = -1.0, y, z;
y = sin(x) - cos(x);
assert(y > 0);
z = log(y); /* log(y) nur für positive y definiert */
/* Ausgabe: Assertion failed: y > 0, file ... */

atan

Bibliothek: #include <math.h>
Prototyp: double atan(double x);
Rückgabewert: Arcustangens von x im Bogenmaß (zwischen -Pi/2 und +Pi/2)
Beschreibung: Berechnet den Arcustangens des Argumentes x; Umkehrfunktion des Tangens.
Beispiel:
printf("atan(-1.0) = %7.4f\n", atan(-1.0));
/* Ausgabe: atan(-1.0) = -0.7854 */

atan2

Bibliothek: #include <math.h>
Prototyp: double atan2(double y, double x);
Rückgabewert: Gibt einen Wert zwischen -Pi/2 und +Pi/2 zurück. Sind die Argumente x und y beide 0, so erhält die Fehlervariable errno den Wert EDOM und eine Fehlermeldung wird auf stderr ausgegeben. Der Rückgabewert ist in diesem Fall 0.
Beschreibung: Berechnet den Arcustangens von y/x.
Beispiel:
double x = 3, y = 3; /* y/x = 1 */
printf("atan2(y,x) = %10f\n",atan2(y,x));
/* Ausgabe: atan2(y,x) = 0.785398 */

atexit

Bibliothek: #include <stdlib.h>
Prototyp: int atexit(void(*func)(void));
Rückgabewert: Im Fehlerfall ein Wert ungleich 0, sonst 0.
Beschreibung: Der Funktion atexit wird ein Zeiger func auf eine Funktion vom Typ void übergeben, die am Ende des Programms aufgerufen werden soll. Durch mehrere aufeinanderfolgende Aufrufe von atexit werden Zeiger auf weitere Funktionen registriert, die nach dem Stack-Prinzip (last in first out) verwaltet werden.
Beispiel:
void func1(void) 
  { printf("Das ist Funktion func1.\n");}

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

main()
  {
  atexit(func1);
  atexit(func2);
  printf("\nEnde des Programms.\n");
  }
/* Ausgabe: 
  Ende des Programms.
  Das ist Funktion func2.
  Das ist Funktion func1. */ 

atof

Bibliothek: #include <stdlib.h>
Prototyp: double atof(const char *s);
Rückgabewert: Gibt den double-Wert der in der Zeichenkette gespeicherten Zahl zurück. Bei nicht auswertbarer Zeichenkette wird 0 zurückgegeben.
Beschreibung: Wandelt eine als Zeichenkette gespeicherte Zahl in einen Wert vom Typ double um. Beim ersten Zeichen, das nicht als Teil einer Gleitpunktzahl interpretiert werden kann, wird die Umwandlung beendet. Leerzeichen werden ignoriert.
Beispiel:
char *string = "-12.356e+2";
double z;
z= atof(string);
printf("z = %.2f\n",z);
/* Ausgabe: z = -1235.60 */

atoi

Bibliothek: #include <stdlib.h>
Prototyp: int atoi(const *s);
Rückgabewert: Gibt den int-Wert der in der Zeichenkette gespeicherten Zahl zurück. Falls eine Auswertung nicht möglich ist, wird 0 zurückgegeben.
Beschreibung: Wandelt eine als Zeichenkette gespeicherte dezimale Ganzzahl in einen int-Wert um. Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung beendet. Ein Dezimalpunkt oder Exponent wird nicht als Teil der Zahl angesehen.
Beispiel:
char *s= "+123 Autos";
printf("atoi(s) = %d\n",atoi(s));
/* Ausgabe: atoi(s) = 123 */

atol

Bibliothek: #include <stdlib.h>
Prototyp: long atol(const char *s);
Rückgabewert: Gibt den long-Wert der in der Zeichenkette gespeicherten Zahl zurück. Falls eine Auswertung nicht möglich ist, wird 0 zurückgegeben.
Beschreibung: Wandelt eine als Zeichenkette gespeicherte dezimale Ganzzahl in einen long-Wert um. Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung beendet. Ein Dezimalpunkt oder Exponent wird nicht als Teil der Zahl angesehen.
Beispiel:
char *s= "12345678.-- Dollar";
printf("atol(s) = %ld\n",atol(s));
/* Ausgabe: atol(s) = 12345678 */

bsearch

Bibliothek: #include <stdlib.h>
Prototyp: void *bsearch (const void *key, const void *array, size_t n, size_t size, int (*compare)());
Rückgabewert: Gibt einen Zeiger auf das erste Vektorelement zurück, das mit dem gesuchten Wert übereinstimmt. Gibt es ein solches Vektorelement nicht, so wird der NULL-Zeiger zurückgegeben.
Beschreibung: Verwendet binäre Suche, um in einem sortierten Vektor array nach dem durch key adressierten Wert zu suchen. Der Vektor enthält n Vektorelemente der Größe size. Der Datentyp size_t ist in stdlib.h als unsigned int definiert. Das letzte Argument compare ist ein Zeiger auf eine Funktion, die den gesuchten Wert mit einem Vektorelement vergleicht.
Beispiel:
int scmp(char **s1, char **s2) { return strcmp(*s1, *s2); }

main()
  {
  char *farben[] = 
    {"rot","orange","gelb","grün","blau","violett"};
  char *key = "schwarz";

  ...
  
  if (bsearch(key,farben,5,sizeof(char*),scmp) == NULL)
    printf("Farbe %s nicht gefunden\n",key);
  ...
  }

calloc

Bibliothek: #include <stdlib.h>
Prototyp: void *calloc(size_t n, size_t size);
Rückgabewert: Zeiger auf Anfangsadresse des zugeteilten Speicherbereiches
Beschreibung: Reserviert Platz im Hauptspeicher für einen Vektor mit n Elementen der Größe size. size_t ist in stdlib.h als unsigned int definiert. Jedes Element wird mit dem Wert 0 initialisiert. Ist nicht genügend Speicherplatz vorhanden, wird ein NULL-Zeiger zurückgeliefert.
Beispiel:
if (calloc(5,sizeof(int)) == NULL)
  printf("Nicht genügend Speicher\n");

chdir

Bibliothek: #include <unistd.h>
Prototyp: int chdir (const char *pfad);
Rückgabewert: im Erfolgsfall 0, im Fehlerfall -1
Beschreibung: Wechsel in das angegebene Verzeichnis.
Beispiel:
erg = chdir("/var/log/"); 

ceil

Bibliothek: #include <math.h>
Prototyp: double ceil(double x);
Rückgabewert: x aufgerundet
Beschreibung: Liefert kleinste ganze Zahl, die größer oder gleich x ist (Aufrundung).
Beispiel:
printf("ceil(2.3) = %4.1f\n", ceil(2.3));
/* Ausgabe: ceil(2.3) = 3.0 */

clearerr

Bibliothek: #include <stdio.h>
Prototyp: void clearerr(FILE *fp);
Rückgabewert: keiner
Beschreibung: Löscht das Fehler-Flag und das Dateiende-Flag der mit fp verbundenen Datei.
Beispiel:
clearerr(fp); 

clock

Bibliothek: #include <time.h>
Prototyp: clock_t clock (void);
Rückgabewert: Prozessorzeit in "Ticks" (systemabhängig)
Beschreibung: Bestimmt die Prozessorzeit, die das aufrufende Programm bis dahin verbraucht hat. clock_t ist in time.h als long definiert. Die Einheit für Prozessorzeit ist abhängig vom Compiler. Durch Division mit der in time.h definierten Konstanten CLK_TCK sollte das Ergebnis in Sekunden umgerechnet werden.
Beispiel:
z = clock(); 
/* weist z die Anzahl von "Ticks" zu,
die seit Programmstart vergangen sind */

closedir

Bibliothek: #include <dirent.h>
#include <sys/types.h>
Prototyp: int closedir (DIR *dirp);
Rückgabewert: im Erfolgsfall 0, im Fehlerfall -1
Beschreibung: Schliesst einen Verzeichnis-Stream und gibt die belegten Resourcen zurück.
Beispiel:
erg = closedir(dir); 

cos

Bibliothek: #include <math.h>
Prototyp: double cos(double x);
Rückgabewert: cos(x)
Beschreibung: Liefert den Cosinus von x (im Bogenmaß). Ist der Argumentwert zu groß für ein signifikantes Ergebnis, so wird 0 zurückgegeben und errno erhält den Wert ERANGE.
Beispiel:
printf("cos(0.0) = %4.1f\n", cos(0.0));
/* Ausgabe: cos(0.0) = 1.0 */

cosh

Bibliothek: #include <math.h>
Prototyp: double cosh(double x);
Rückgabewert: cosh(x)
Beschreibung: Liefert den Cosinus Hyperbolicus von x. Ist das Ergebnis zu groß, so wird HUGE_VAL zurückgegeben und errno erhält den Wert ERANGE.
Beispiel:
printf("cosh(-2.0) = %6.4f\n", cosh(-2.0));
/* Ausgabe: cosh(-2.0) = 3.7622 */

ctime

Bibliothek: #include <time.h>
Prototyp: char *ctime(const time_t *zeit);
Rückgabewert: Anfangsadresse des Zeitstrings
Beschreibung: Konvertiert Datum und Uhrzeit in einen String. zeit ist die Anzahl der Sekunden seit der UNIX-Epoche, dem 1.1.1970 00:00:00 Uhr (GMT). Der erzeugte String hat das Format Wochentag Monat Monatstag Zeit (hh:mm:ss) Jahr (vierstellig). time_t ist in time.h als long definiert.
Beispiel:
time_t sec;
time(&sec);
printf("Datum und Zeit: %s\n", ctime(&sec));
/* Ausgabe: Datum und Zeit: Mon Oct 28 09:15:48 1996 */

difftime

Bibliothek: #include <time.h>
Prototyp: double difftime(time_t time2, time_t time1);
Rückgabewert: Differenz time2 - time1
Beschreibung: Berechnet die Differenz von time2 und time1 als double-Wert in Sekunden time_t ist in time.h als long definiert ein solcher Wert wird von time() geliefert.
Beispiel:
printf("Arbeitszeit: %.0f Sekunden\n", difftime(stoptime,starttime));
/* Ausgabe der Differenz zwischen starttime und stoptime */

div

Bibliothek: #include <stdlib.h>

Protoyp: div_t div(int x,int y);

Rückgabewert: Struktur vom Typ div_t
Beschreibung: Dividiert x durch y und legt Ergebnis und Rest in einer Struktur vom Typ div_t ab. div_t ist in stdlib.h definiert.
Beispiel:
div_t res;
res = div(10,3);
printf("10/3 = %d, Rest %d\n",res.quot,res.rem);
/* Ausgabe: 10/3 = 3 Rest 1 */

exit

Bibliothek: #include <stdlib.h>
Prototyp: void exit(int status);
Rückgabewert: keiner
Beschreibung: Beendet ein Programm. Dateipuffer werden übertragen und Dateien werden geschlossen. status stellt den Exit-Code dar.
Beispiel:
exit(1); /* beendet das Programm und liefert den 
Exit-Code 1 zurück */

exp

Bibliothek: #include <math.h>
Prototyp: double exp(double x);
Rückgabewert: ex
Beschreibung: Berechnet den Wert der Exponentialfunktion für x.
Beispiel:
printf("exp(-3.0) = %7.4f\n", exp(-3.0));
/* Ausgabe: exp(-3.0) = 0.0498 */

fabs

Bibliothek: #include <math.h>
Prototyp: double fabs(double x);
Rückgabewert: | x |
Beschreibung: Liefert den Absolutwert einer Gleitkommazahl
Beispiel:
printf("fabs(-3.8) = %3.1f\n", fabs(-3.8));
/* Ausgabe: fabs(-3.8) = 3.8 */

fclose

Bibliothek: #include <stdio.h>
Prototyp: int fclose(FILE *fp);
Rückgabewert: Datei geschlossen: 0; ungültiger File-Pointer: EOF
Beschreibung: Schließt die mit fp verbundene Datei überträgt den Inhalt des Dateipuffers. Der Speicherbereich des E/A-Puffers wird wieder freigegeben.
Beispiel:
if (fclose(fp) == 0)
  printf("Datei wurde geschlossen\n");

feof

Bibliothek: #include <stdio.h>
Prototyp: int feof(FILE *fp);
Rückgabewert: Dateiende-Flag gesetzt: Wert ungleich 0; andernfalls 0
Beschreibung: Das Makro prüft, ob das Dateiende erreicht ist.
Beispiel:
while (!feof(fp))
  /* führt nachfolgenden Befehl solange aus,
  bis das Dateiende erreicht ist */

ferror

Bibliothek: #include <stdio.h>
Prototyp: int ferror(FILE *fp);
Rückgabewert: Fehler-Flag gesetzt: Wert ungleich 0; andernfalls 0
Beschreibung: Das Makro überprüft, ob ein Fehler beim Zugriff auf eine Datei auftrat.
Beispiel:
if (ferror(fp)) 
  printf("Fehler beim Zugriff\n");

fflush

Bibliothek: #include <stdio.h>
Prototyp: int fflush(FILE *fp);
Rückgabewert: Im Fehlerfall EOF, andernfalls 0
Beschreibung: Überträgt den Inhalt des Dateipuffers:
Schreibmodus: Dateipuffer wird geschrieben
Lesemodus: Puffer wird geleert
Beispiel:
if (fflush(fp) == EOF)
  printf("Puffer nicht geschrieben\n");

fgetc

Bibliothek: #include <stdio.h>
Prototyp: int fgetc(FILE *fp);
Rückgabewert: gelesenes Zeichen, bei Fehler oder Dateiende EOF
Beschreibung: Liest aus der Datei das Zeichen von der aktuellen Position (Dateizeiger wird um eins erhöht).
Beispiel:
c = fgetc(fp); 
/* weist c das nächste Zeichen der Datei zu */

fgetpos

Bibliothek: #include <stdio.h>
Prototyp: int fgetpos(FILE *fp, fpos_t *ppos);
Rückgabewert: Im Fehlerfall Wert ungleich 0; sonst 0
Beschreibung: Ermittelt die aktuelle Position in der Datei und kopiert aktuelle Position in durch ppos adressierte Variable. fpos_t ist in stdio.h als long definiert. Im Fehlerfall erhält errno den Wert EINVAL oder EBADF.
Beispiel:
fgetpos(fp,&pos);
/* sichert aktuelle Position in pos */

fgets

Bibliothek: #include <stdio.h>
Prototyp: char *fgets(char *string, int n, FILE *fp);
Rückgabewert: Im Fehlerfall ein NULL-Pointer, andernfalls einen Zeiger auf string
Beschreibung: Liest Zeichenfolge aus der Datei und kopiert sie in einen durch string adressierten Speicherbereich; am Ende wird "\0" angefügt. Eingelesen wird bis n-1 Zeichen gelesen wurden oder bis ein Newline-Zeichen auftritt.
Beispiel:
if (fgets(name,21,fp) != NULL) 
  printf("1. Name: %s\n", name);
  /* Ausgabe: 1. Name: xxxx */

floor

Bibliothek: #include <math.h>
Prototyp: double floor(double x);
Rückgabewert: x abgerundet
Beschreibung: Ermittelt die größte ganze Zahl, die kleiner oder gleich x ist (Abrundung)
Beispiel:
printf("floor(1.9) = %4.1f\n", floor(1.9));
/* Ausgabe: floor(1.9) = 1 */

fmod

Bibliothek: #include <math.h>
Prototyp: double fmod(double x,double y);
Rückgabewert: Rest der Division x/y
Beschreibung: Modulo-Division der double-Werte x und y
Beispiel:
printf("fmod(9.5,4.5) = %3.1f\n", fmod(9.5,4.5));
/* Ausgabe: fmod(9.5,4.5) = 0.5 */

fopen

Bibliothek: #include <stdio.h>
Prototyp: FILE *fopen(const char *name, const char *modus);
Rückgabewert: File-Pointer; im Fehlerfall NULL
Beschreibung: Öffnet eine Datei name in der Zugriffsart modus. Durch Anhängen des Buchstabens "t" bzw. "b" an modus kann zwischen Binär- und Textmodus gewählt werden (falls das Betriebssystem hier unterscheidet). FILE ist in stdio.h definiert. Liste der verschiedenen Modi:

"r" Lesen (Datei muß existieren)
"r+" Lesen/Schreiben (Datei muß existieren)
"w" Schreiben (wenn Datei nicht existiert, wird sie angelegt)
"w+" Lesen / Schreiben (wenn Datei nicht existiert, wird sie angelegt)
"a" Schreiben ab Dateiende
"a+" Schreiben ab Dateiende / Lesen

Beispiel:
fp = fopen("bsp.txt","r");
/* öffnet die bereits existierende Datei bsp.txt
zum Lesen (fp wird mit der Datei verbunden) */

fprintf

Bibliothek: #include <stdio.h>
Prototyp: int fprintf(FILE *fp,const char formatstring, ... );
Rückgabewert: Anzahl der ausgegebenen Zeichen; im Fehlerfall EOF
Beschreibung: Schreibt entsprechend den Angaben im Formatstring in die mit fp verbundene Datei (siehe auch printf).
Beispiel:
fprintf(fp,"2 * 2 = %d \n",2*2);
/* Ausgabe von: 2 * 2 = 4 in die Datei */

fputc

Bibliothek: #include <stdio.h>
Prototyp: int fputc(int c,FILE *fp);
Rückgabewert: Im Fehlerfall EOF; andernfalls ausgegebenes Zeichen
Beschreibung: Schreibt das Zeichen c auf die aktuelle Dateiposition (wirkungsgleich mit dem Makro putc)
Beispiel:
fputc(c,fp); 
/* schreibt das Zeichen c an die
aktuelle Position in die Datei */

fputs

Bibliothek: #include <stdio.h>
Prototyp: int fputs(const char *string, FILE *fp);
Rückgabewert: Im Fehlerfall EOF; andernfalls von EOF verschiedener Wert
Beschreibung: Schreibt die Zeichenkette string in Datei. Das Stringende-Zeichen '\0' wird nicht in die Datei geschrieben.
Beispiel:
fputs(string,fp); 
  /* schreibt string in die Datei */

fread

Bibliothek: #include <stdio.h>
Prototyp: size_t fread(void *buffer, size_t size, size_t n, FILE *fp);
Rückgabewert: Anzahl der tatsächlich gelesenen Datenobjekte (ist diese kleiner n -> Fehler oder EOF)
Beschreibung: Liest bis zu n Datenobjekte der Länge size aus der Datei ein und schreibt sie in den Speicherbereich mit Startadresse puffer. size_t ist in stdio.h als unsigned int definiert.
Beispiel:
fread(puffer,sizeof(pufferelement),100,fp);
/* liest 100 Elemente aus der Datei in den puffer */

free

Bibliothek: #include <stdlib.h>
Prototyp: void free(void *ptr);
Rückgabewert: keiner
Beschreibung: Gibt den Speicherbereich frei, auf dessen Anfang ptr zeigt (Speicher muß zuvor durch malloc, calloc oder realloc reserviert worden sein). Ist ptr ein NULL-Zeiger, passiert nichts.
Beispiel:
free(ptr); 

freopen

Bibliothek: #include <stdio.h>
Prototyp: FILE *freopen(const char *name, const char *modus, FILE *fp);
Rückgabewert: File-Pointer für die neu geöffnete Datei; im Fehlerfall NULL-Zeiger
Beschreibung: Schließt die mit fp verbundene Datei und öffnet die Datei name mit der Zugriffsart modus unter Verwendung des alten Filepointers (Beschreibung der Zugriffsarten bei fopen)
Beispiel:
freopen("bsp.txt","w",stdout);
/* lenkt die Standardausgabe in die Datei bsp.txt um */ 

frexp

Bibliothek: #include <math.h>
Prototyp: double frexp(double x, int *ptr);
Rückgabewert: Wert der Mantisse
Beschreibung: Zerlegt den double-Wert x in Mantisse m und Exponent exp (zur Basis 2). Der Exponent exp wird an der durch ptr adressierten Speicherstelle abgelegt. Ist x=0, dann erhalten m und exp den Wert 0.
Beispiel:
m = frexp(9.5,&exp);
printf("Mantisse m = %f, exp = %d\n",m,exp);
/* Ausgabe: Mantisse m = 0.5937..., exp = 4 */

fscanf

Bibliothek: #include <stdio.h>
Prototyp: int fscanf(FILE *fp, const char *formatstring [,arg1,arg2,..]);
Rückgabewert: Anzahl der tatsächlich gelesenen Datenfelder; falls das Dateiende erreicht wurde EOF
Beschreibung: Liest Elemente aus der Datei, interpretiert sie unter Kontrolle des Formatstrings und legt sie in den durch arg1, arg2, ... adressierten Speicherplätzen ab. formatstring wird in der bei scanf beschriebenen Weise gebildet arg1, ... ist ein Zeiger auf eine Variable, deren Typ mit der entsprechenden Typangabe im Format-String übereinstimmen muß.
Beispiel:
fscanf(fp,"%10s %ld",name,&nummer);
printf("name = %s nummer = %ld\n",name,nummer);

fseek

Bibliothek: #include <stdio.h>

Protoyp: int fseek(FILE *fp, long offset, int basis);

Rückgabewert: Im Fehlerfall Wert ungleich 0; andernfalls 0
Beschreibung: Verschiebt den Datei-Zeiger um offset Bytes
  • vom Dateianfang, falls basis = 0
  • von der aktuellen Position, falls basis = 1
  • vom Dateiende, falls basis = 2

Der Zeiger darf nicht vor den Anfang der Datei gesetzt werden.

Beispiel:
fseek(fp,48L,0);
/* setzt den Seek-Zeiger 48 Bytes nach Dateianfang */

fsetpos

Bibliothek: #include <stdio.h>
Prototyp: int fsetpos(FILE *fp,const fpos_t *ppos);
Rückgabewert: 0; im Fehlerfall von 0 verschiedener Wert
Beschreibung: Setzt den Seek-Zeiger der Datei an die neue Position *ppos (z.B. durch fgetpos ermittelt). fpos_t ist in stdio.h als long definiert. Tritt ein Fehler auf, so erhält errno den Wert EINVAL oder EBADF.
Beispiel:
fsetpos(fp,&pos);
/* setzt den Seek-Pointer der Datei an die durch pos 
gekennzeichnete Stelle */

ftell

Bibliothek: #include <stdio.h>
Prototyp: long ftell(FILE *fp);
Rückgabewert: aktuelle Position des Seek-Zeigers; im Fehlerfall -1L
Beschreibung: Ermittelt die aktuelle Position in der Datei. Im Fehlerfall erhält errno den Wert EINVAL (invalid argument) oder EBADF (bad file number).
Beispiel:
pos = ftell(fp);
/* pos wird die aktuelle Position 
in der Datei zugewiesen */

fwrite

Bibliothek: #include <stdio.h>
Prototyp: size_t fwrite(void *buffer, size_t size, size_t n, FILE *fp);
Rückgabewert: Anzahl der Datenobjekte, die tatsächlich in die Datei geschrieben wurden.
Beschreibung: Schreibt n Datenobjekte der Größe size aus dem durch buffer adressierten Puffer in die Datei. size_t ist in stdio.h als unsigned int definiert.
Beispiel:
fwrite(puffer,sizeof(pufferelement),4,fp);
/* schreibt 4 pufferelemente aus puffer in die Datei */

getc

Bibliothek: #include <stdio.h>
Prototyp: int getc(FILE *fp);
Rückgabewert: eingelesenes Zeichen, bei Fehler oder Dateiende EOF
Beschreibung: Das Makro liest das nächste Zeichen aus der Datei.
Beispiel:
c = getc(fp);
/* weist c das nächste Zeichen aus der Datei zu */

getchar

Bibliothek: #include <stdio.h>
Prototyp: int getchar(void);
Rückgabewert: eingelesenes Zeichen, bei Fehler oder Dateiende EOF
Beschreibung: Das Makro liest das nächste Zeichen von stdin
Beispiel:
c = getchar();
/* weist c das nächste Zeichen von stdin zu */

getenv

Bibliothek: #include <stdlib.h>
Prototyp: char *getenv(const char *name);
Rückgabewert: Zeiger auf den entsprechenden Eintrag; kein Name: NULL
Beschreibung: Sucht in der Tabelle der Umgebungsvariablen nach dem zu name gehörenden Eintrag.
Beispiel:
ptr = getenv("PATH");
/* weist ptr den Inhalt des "PATH"-Eintrages 
in der Umgebung zu */

gets

Bibliothek: #include <stdio.h>
Prototyp: char *gets(char *buffer);
Rückgabewert: Funktion liefert ihr Argument als Rückgabe, bei Fehler oder Dateiende NULL-Zeiger
Beschreibung: Liest eine Textzeile bis zum Newline-Zeichen von stdin und schreibt sie in den durch buffer adressierten Speicherbereich. Newline wird durch "\0" ersetzt. Achtung: Gefahr des 'Buffer overflow', falls die Eingabezeile länger als der Puffer ist - besser fgets() verwenden.
Beispiel:
char buffer[100];
gets(buffer);
/* liest Textzeile in buffer ein */

gmtime

Bibliothek: #include <time.h>
Prototyp: struct tm *gmtime(const time_t *sec);
Rückgabewert: Zeiger auf Struktur vom Typ tm
Beschreibung: Wandelt die mit sec angegebene Anzahl von Sekunden, die seit der UNIX-Epoche (1.1.1970 0 Uhr GMT) vergangen sind, in das entsprechende Datum um (GMT = Greenwich Mean Time). Die Ortszeit-Struktur struct tm hat folgende Elemente:
  • int tm_sec Sekunden nach voller Minute (0-61)
  • int tm_min Minuten nach voller Stunde (0-59)
  • int tm_hour Stunden seit Mitternacht (0-23)
  • int tm_mday Tag im Monat (1-31)
  • int tm_mon Monat nach Januar (0-11)
  • int tm_year Jahr minus 1900
  • int tm_wday Wochentag (0-6, 0=Sonntag)
  • int tm_yday Tag im Jahr nach 1. Januar (0-365)
  • int tm_isdst >0: Sommerzeit, =0: Winterzeit, <0: unbekannt
Beispiel:
time_t sec;
time(&sec);
printf("GMT: %s\n", asctime(gmtime(&sec)));

isalnum

Bibliothek: #include <ctype.h>
Prototyp: int isalnum(int c);
Rückgabewert: alphanumerisches Zeichen: Wert ungleich 0; andernfalls 0
Beschreibung: Das Makro überprüft, ob das Zeichen in c ein alphanumerisches Zeichen ist, d.h. ein Buchstabe oder eine Ziffer des zugrundeliegenden Alphabets (Zeichen 0 bis 127 im ASCII).
Beispiel:
if (isalnum(c))
  printf("%c ist alphanumerisch\n",c);

isalpha

Bibliothek: #include <ctype.h>
Prototyp: int isalpha(int c);
Rückgabewert: kein Buchstabe: 0; Buchstabe: Wert ungleich 0
Beschreibung: Das Makro prüft ob das Zeichen c ein Buchstabe des zugrundeliegenden Alphabets ist (ASCII ohne Umlaute).
Beispiel:
if (isalpha(c))
  printf("%c ist ein Buchstabe\n",c);

iscntrl

Bibliothek: #include <ctype.h>
Prototyp: int iscntrl(int c);
Rückgabewert: Steuerzeichen: Wert ungleich 0; andernfalls : 0
Beschreibung: Das Makro prüft, ob das Zeichen c ein Steuerzeichen ist (Zeichen 0 bis 31 oder 127 in ASCII).
Beispiel:
if (iscntrl(c))
  printf("Steuerzeichen\n");

isdigit

Bibliothek: #include <ctype.h>
Prototyp: int isdigit(int c);
Rückgabewert: Ziffer: Wert ungleich 0; andernfalls 0
Beschreibung: Das Makro prüft, ob das Zeichen c eine Ziffer (0, 1, ..., 9) ist.
Beispiel:
if (isdigit(c))
  printf("%c ist eine Ziffer\n", c);

isgraph

Bibliothek: #include <ctype.h>
Prototyp: int isgraph(int c);
Rückgabewert: grafisches Zeichen: Wert ungleich 0; andernfalls 0
Beschreibung: Das Makro prüft, ob das Zeichen c ein druckbares Zeichen, aber kein Leerzeichen ist (Zeichen 33 bis 126 in ASCII - wie isprint ohne Leerzeichen).
Beispiel:
if (isgraph(c))
  printf("%c ist ein grafisches Zeichen\n",c);

islower

Bibliothek: #include <ctype.h>
Prototyp: int islower (int c);
Rückgabewert: Kleinbuchstabe: Wert ungleich 0; andernfalls 0
Beschreibung: Das Makro prüft, ob das Zeichen c ein Kleinbuchstabe ist (ASCII ohne Umlaute).
Beispiel:
if (islower(c))
  printf("%c ist ein Kleinbuchstabe\n",c);

isprint

Bibliothek: #include <ctype.h>
Prototyp: int isprint(int c);
Rückgabewert: druckbares Zeichen: Wert ungleich 0; andernfalls 0
Beschreibung: Das Makro prüft, ob das Zeichen c ein druckbares Zeichen ist (Zeichen 32 bis 127 im ASCII)
Beispiel:
if (isprint(c))
printf("%c ist ein druckbares Zeichen\n",c);

ispunct

Bibliothek: #include <ctype.h>
Prototyp: int ispunct(int c);
Rückgabewert: Interpunktionszeichen: Wert ungleich 0; andernfalls 0
Beschreibung: Das Makro prüft, ob das Zeichen c ein Interpunktionszeichen ist (alle druckbaren Zeichen und Leerzeichen ohne Ziffern und Buchstaben).
Beispiel:
if (ispunct(c))
  printf("%c ist ein Interpunktionszeichen",c);

isspace

Bibliothek: #include <ctype.h>
Prototyp: int isspace (int c);
Rückgabewert: Leerzeichen: Wert ungleich 0; andernfalls 0
Beschreibung: Das Makro prüft, ob das Zeichen c ein "Whitespace"-Zeichen ist, d. h. horizontaler oder vertikaler Tabulator, Newline, Formfeed (Seitenvorschub), Carriage-Return oder Leerzeichen.
Beispiel:
if (isspace(c))
  printf("%c ist ein Leerzeichen\n",c);

isupper

Bibliothek: #include <ctype.h>
Prototyp: int isupper(int c);
Rückgabewert: Großbuchstabe: Wert ungleich 0; andernfalls 0
Beschreibung: Das Makro prüft, ob das Zeichen c ein Großbuchstabe ist (ASCII ohne Umlaute).
Beispiel:
if (isupper(c))
  printf("%c ist ein Großbuchstabe\n",c);

isxdigit

Bibliothek: #include <ctype.h>
Prototyp: int isxdigit(int c);
Rückgabewert: Hexadezimalziffer: Wert ungleich 0; andernfalls 0
Beschreibung: Das Makro prüft, ob das Zeichen c eine Hexadezimalziffer ist (0 bis 9, a bis f und A bis F)
Beispiel:
if (isxdigit(c))
  printf("%c ist eine Hexadezimalziffer\n",c);

labs

Bibliothek: #include <stdlib.h>
Prototyp: long labs(long x);
Rückgabewert: | x |
Beschreibung: Liefert den Absolutwert des long-Wertes x
Beispiel:
printf("labs(-9876543) = %ld",labs(-9876543));
/* Ausgabe: labs(-9876543) = 9876543 */

ldexp

Bibliothek: #include <math.h>
Prototyp: double ldexp(double m, int exp);
Rückgabewert: m * 2; bei Überlauf HUGE_VAL mit Vorzeichen
Beschreibung: Berechnet den Wert m * 2; im Falle eines Überlauf erhält errno den Wert ERANGE
Beispiel:
printf("ldexp(3.0,4) = %.1f",ldexp(3.0,4));
/* Ausgabe: ldexp(3.0,4) = 48 */

ldiv

Bibliothek: #include <stdlib.h>
Prototyp: ldiv_t ldiv(long x, long y);
Rückgabewert: Struktur von Typ ldiv_t
Beschreibung: Dividiert die beiden long-Werte x/y, dabei werden der ganzzahlige Anteil des Ergebnisses und der Rest in einer Variablen vom Typ ldiv_t abgelegt. ldiv_t wird in stdlib.h definiert.
Beispiel:
ldiv_t result;
result = ldiv(1000000,45000);
printf("ldiv(1000000,45000) = %ld Rest %ld",
       result.quot,result.rem);
/* Ausgabe: ldiv(1000000,45000) = 22 Rest 10000 */

localtime

Bibliothek: #include <time.h>
Prototyp: struct tm *localtime(const time_t *sec);
Rückgabewert: Zeiger auf Struktur vom Typ tm
Beschreibung: Wandelt die Anzahl der Sekunden (sec) seit 1.1.1970 0 Uhr in das lokale Datum und Uhrzeit um time_t ist in time.h als long definiert. Die Ortszeit-Struktur struct tm hat folgende Elemente:
  • int tm_sec Sekunden nach voller Minute (0-61)
  • int tm_min Minuten nach voller Stunde (0-59)
  • int tm_hour Stunden seit Mitternacht (0-23)
  • int tm_mday Tag im Monat (1-31)
  • int tm_mon Monat nach Januar (0-11)
  • int tm_year Jahr minus 1900
  • int tm_wday Wochentag (0-6, 0=Sonntag)
  • int tm_yday Tag im Jahr nach 1. Januar (0-365)
  • int tm_isdst >0: Sommerzeit, =0: Winterzeit, <0: unbekannt
Beispiel:
struct tm *zeit;
time_t sec;
time(&sec);
printf("Datum/Uhrzeit: %s\n", 
       asctime(localtime(&sec)));
/* das lokale Datum und Uhrzeit wird ausgegeben */ 

log

Bibliothek: #include <math.h>
Prototyp: double log(double x);
Rückgabewert: ln(x); bei Argument <= 0: HUGE_VAL
Beschreibung: Liefert den natürlichen Logarithmus von x bei negativen Argumenten erhält errno den Wert EDOM. Ist x = 0 so erhält errno jedoch ERANGE.
Beispiel:
printf("ln(0.5) = %7.4f\n",log(0.5));
/* Ausgabe: ln(0.5) = -0.6931 */

log10

Bibliothek: #include <math.h>
Prototyp: double log10(double x);
Rückgabewert: lg(x); bei Argument <= 0: HUGE_VAL
Beschreibung: Liefert den dekadischen Logarithmus von x. Bei negativen Argumenten erhält errno den Wert EDOM, ist x = 0 so erhält errno den Wert ERANGE.
Beispiel:
printf("lg(10) = %4.1f\n", log10(10));
/* Ausgabe: lg(10) = 1.0 */

longjmp

Bibliothek: #include <setjmp.h>
Prototyp: void longjmp(jmp_buf env, int retwert);
Rückgabewert: keiner
Beschreibung: Ermöglicht Sprünge, die nicht an eine feste Zeile im Programm gebunden sind. Das Programm verzweigt zu der Stelle, an der zuvor die Funktion setjmp aufgerufen wurde. Der alte Maschinenzustand und die Stack-Umgebung, welche in env gespeichert sind, werden wiederhergestellt. retwert stellt einen Wert ungleich 0 dar (um von setjmp unterscheidbar zu sein). jmp_buf ist in setjmp.h definiert.
Beispiel:
jmp_buf env;
int retwert;
...
if (setjmp(env) == 0)
printf("Zielmarke initialisiert\n");
else printf("longjmp-Sprung erfolgt\n");
...
longjmp(env,retwert);
/* Ausgabe: Zielmarke initialisiert, wenn TRUE oder
longjmp-Sprung erfolgt, wenn FALSE */

malloc

Bibliothek: #include <stdlib.h>
Prototyp: void *malloc(size_t size);
Rückgabewert: typenloser Zeiger auf Startadresse des bereitgestellten Speichers; im Fehlerfall NULL-Zeiger
Beschreibung: Reserviert einen Speicherbereich von size Bytes. size_t ist in stdlib.h als unsigned int definiert.
Beispiel:
int *feld
feld = (int *) malloc(10*sizeof(int));

memchr

Bibliothek: #include <string.h>
Prototyp: void *memchr(const void *buffer, int c, size_t n);
Rückgabewert: Zeiger auf erstes Auftreten des Zeichens c im Puffer
Beschreibung: Bestimmt in den ersten n Bytes des Puffers buffer das erste Auftreten des Zeichens c. size_t ist in string.h als unsigned int definiert.
Beispiel:
Zeiger = memchr(puffer,'!',55);
/* Zeiger = Adresse des ersten Auftretens 
des Zeichens '!' in den vorderen 55 Bytes 
des Puffers */

memcmp

Bibliothek: #include <string.h>
Prototyp: int memcmp(const void *buf1, const void *buf2, size_t n);
Rückgabewert:
  • < 0, wenn buf1 "kleiner" buf2 ist
  • = 0, wenn beide identisch sind
  • > 0, wenn buf1 "größer" als buf2 ist
Beschreibung: Vergleicht die ersten n Bytes des Puffers buf1 mit denen des buf2. Der Vergleich bricht beim ersten verschiedenen Zeichen ab. size_t ist in string.h als unsigned int definiert.
Beispiel:
if (memcmp(s1,s2,20) != 0)
  printf("Strings sind ungleich\n");
else
  printf("Strings sind gleich\n");

memcpy

Bibliothek: #include <string.h>
Prototyp: void *memcpy(void *dest, const void *src, size_t n);
Rückgabewert: Zeiger auf dest
Beschreibung: Kopiert Anzahl n Bytes von der Quelle src zum Ziel dest. size_t ist in string.h als unsigned int definiert. Im Unterschied zu memmove wird bei einer eventuellen Überlappung der Speicherbereiche nicht sichergestellt, daß zuerst gelesen und dann geschrieben wird.
Beispiel:
zeiger = memcpy(ziel,quelle,100);
/* kopiert 100 Bytes von quelle nach ziel,
zeiger erhält die Adresse von ziel */

memmove

Bibliothek: #include <string.h>
Prototyp: void *memmove(void *dest, const void *src,size_t n);
Rückgabewert: Zeiger auf dest
Beschreibung: Kopiert n Bytes von src nach dest. size_t ist in string.h als unsigned int definiert. Im Unterschied zu memcpy wird bei einer eventuellen Überlappung der Speicherbereiche zuerst gelesen und dann überschrieben.
Beispiel:
zeiger = memmove(ziel,quelle,30);
/* kopiert 30 Bytes von quelle nach ziel, 
zeiger erhält die Adresse von ziel */

memset

Bibliothek: #include <string.h>
Prototyp: void memset(void *dest, int c, unsigned int n);
Rückgabewert: Zeiger auf dest
Beschreibung: Füllt die ersten n Bytes von dest mit dem Wert von c
Beispiel:
memset(s,' ',strlen(s));
/* der String wird mit Leerzeichen überschrieben */

mktime

Bibliothek: #include <time.h>
Prototyp: time_t mktime(struct tm *ptr);
Rückgabewert: Anzahl der Sekunden; im Fehlerfall -1
Beschreibung: Wandelt die durch den Zeiger ptr adressierten Zeitangaben in die Anzahl von Sekunden seit dem 1.1.1970 0 Uhr um. Die Ortszeit-Struktur struct tm hat folgende Elemente:
  • int tm_sec Sekunden nach voller Minute (0-61)
  • int tm_min Minuten nach voller Stunde (0-59)
  • int tm_hour Stunden seit Mitternacht (0-23)
  • int tm_mday Tag im Monat (1-31)
  • int tm_mon Monat nach Januar (0-11)
  • int tm_year Jahr minus 1900
  • int tm_wday Wochentag (0-6, 0=Sonntag)
  • int tm_yday Tag im Jahr nach 1. Januar (0-365)
  • int tm_isdst >0: Sommerzeit, =0: Winterzeit, <0: unbekannt
Beispiel:
time_t heute;
struct tm *morgen;
time(&heute);
morgen = localtime(&heute);
morgen->tm_mday += 1;
if (mktime(morgen) != -1)
  printf("Morgen ist: %s\n",asctime(&zukunft));
else 
  printf("Fehler bei mktime()");

modf

Bibliothek: #include <math.h>
Prototyp: double modf(double x, double *intpart);
Rückgabewert: gebrochener Anteil von x
Beschreibung: Spaltet Fließkommazahl x in einen gebrochen-rationalen und einen ganz-rationalen Teil auf, welcher in intpart gespeichert wird.
Beispiel:
gebr = modf(3.432,&ganz);
printf("gebr = %f, ganz = %d\n",gebr,ganz);
/* Ausgabe: gebr = 0.432, ganz = 3 */

opendir

Bibliothek: #include <dirent.h>
#include <sys/types.h>
Prototyp: DIR *opendir (const char *name);
Rückgabewert: im Erfolgsfall Zeiger auf eine DIR-Struktur, im Fehlerfall NULL-Pointer.
Beschreibung: Öffnet ein Verzeichnis und richtet einen Verzeichnis-Stream ein. Der zurückgelieferte Zeiger dient zum Lesen der Verzeichnisinformation mittels readdir().
Beispiel:
dir = opendir("/var/log/"); 

perror

Bibliothek: #include <stdio.h>
Prototyp: void perror(const char *string);
Rückgabewert: keiner
Beschreibung: Sendet Fehlermeldung zur Standardfehlerausgabe stderr, zuerst wird string ausgegeben, dann ": " und anschließend der Systemfehler.
Beispiel:
perror("Hilfe");
/* erzeugt eine Fehlermeldung der Art:
"Hilfe: bla bla bla" */

popen

Bibliothek: #include <stdio.h>
Prototyp: FILE *popen(const char *command, const char *type);
Rückgabewert: File-Pointer; im Fehlerfall NULL
Beschreibung: Öffnet eine Pipe zum angegebenen Programm command in der Zugriffsart type. command ist ein nullterminierter String, der ein Kommando enthält. Dieses wird an die Shell zur Ausführung übergeben (→ /bin/sh -c command). FILE ist in stdio.h definiert. type ist ein nullterminierter String, der den Modus angibt (lesend oder schreibend):

"r" Lesen (Verarbeiten der Standardausgabe von command)
"w" Schreiben (Schreiben in die Standardeingabe von command)

Beispiel:
fp = popen("ps ax","r");
/* liest die Ausgabe des Kommandos "ps ax" */

pclose

Bibliothek: #include <stdio.h>
Prototyp: int pclose(FILE *stream);
Rückgabewert: Return-Wert des aufgerufenen Programms; im Fehlerfall -1
Beschreibung: Schließt eine vorher geöffnete Pipe. Die Funktion wartet, bis der Prozess beendet wurde.
Beispiel:
retval = pclose(fp);
/* schliesst die Verbindung zur Pipe */

pow

Bibliothek: #include <math.h>
Prototyp: double pow(double x,double y);
Rückgabewert:
  • xy
  • bei Unter- oder Überlauf: +/-HUGE_VAL
  • bei unzulässigen Argumenten: 0
Beschreibung: Berechnet xy. Bei Unter-/Überlauf erhält errno den Wert ERANGE. Falls die Argumente nicht im Definitionsbereich liegen, wird eine entsprechende Fehlermeldung auf stderr ausgegeben. errno erhält den Wert EDOM.
Beispiel:
printf("pow(2.0,2.0) = %4.1f\n",pow(2.0,2.0));
/* Ausgabe: pow(2.0,2.0) = 4.0 */

printf

Bibliothek: #include <stdio.h>
Prototyp: int printf(const char *formatstring,..., [arg1,...,argn]);
Rückgabewert: Anzahl der ausgegebenen Zeichen; im Fehlerfall EOF
Beschreibung: Gibt formatstring auf stdout aus. Formatelemente werden durch Werte aus der Argumentenliste ersetzt. Ein Formatelement bestimmt die Interpretation des Arguments folgendermaßen:

% [Flags] [Feldbreite] [.Genauigkeit] Typ

Flags:
'+'    positive Zahlen mit Vorzeichen
' '    positive Zahlen mit führendem Leerzeichen
'-'    linksbündige Ausgabe

Feldbreite:
Länge des Ausgabefeldes (Ausgabe > Feld: Feld wird vergrößert). Bei Zahlen werden führende Leerzeichen mit Nullen aufgefüllt. Wird als Feldbreite '*' angegeben, bestimmt ein zusätzliches Argument vom Typ int die Feldbreite.

Genauigkeit:
Anzahl der Ziffern hinter dem Dezimalpunkt bei Ausgaben vom Typ f oder e. Anzahl der signifikanten Stellen bei Ausgaben mit g. Mindestzahl an auszugebenden Ziffern bei Ganzzahl-Ausgabe Höchstzahl der auszugebenden Zeichen bei Stringausgabe.

Typ:
gibt Interpretationsart für das Argument an; folgenden Angaben sind möglich

cZeichen(-folge) (auch blanks, tabs und newlines werden gelesen)
Default (keine Feldgrößenangabe): 1 Zeichen
dInteger (dezimal)
iInteger (dezimal) oder oktal (mit führender "0") oder sedezimal (mit führendem "0x" bzw "0X")
oInteger (oktal, mit oder ohne führende "0")
xInteger (sedezimal, mit oder ohne führendem "0x" bzw "0X")
uInteger (dezimal, nur positiv)
e, f, gGleitpunktzahl (beliebige Darstellung)
sString (Ergänzung mit abschließendem '\0')
pPointer
 
h vor d,i,o,u,x Kurze Integerzahl (short)
l vor d,i,o,u,x Lange Integerzahl (long)
l vor e,f,g double
L vor e,f,g long double

Beispiel: printf() wird bei den meisten Beispielen verwendet.

putc

Bibliothek: #include <stdio.h>
Prototyp: int putc(int c, FILE *fp);
Rückgabewert: ausgegebenes Zeichen; Im Fehlerfall EOF
Beschreibung: Das Makro schreibt das Zeichen c auf die aktuelle Position der Datei
Beispiel:
putc(c,fp); 
/* schreibt das Zeichen c an die aktuelle Position
der Datei, die mit fp verbunden ist */

putchar

Bibliothek: #include <stdio.h>
Prototyp: int putchar(int c);
Rückgabewert: ausgegebenes Zeichen; Im Fehlerfall EOF
Beschreibung: Das Makro schreibt das Zeichen c auf die Standardausgabe. (putc(c,stdout) ist wirkungsgleich zu putchar(c)).
Beispiel:
putchar(c); /* gibt das Zeichen c über stdout aus */

puts

Bibliothek: #include <stdio.h>
Prototyp: int puts(const char *string);
Rückgabewert: nicht negativer Wert; im Fehlerfall EOF
Beschreibung: Schreibt den String string auf die Standardausgabe stdout, abschließend wird ein Newline-Zeichen ausgegeben.
Beispiel:
puts("Hello World!");

qsort

Bibliothek: #include <stdlib.h>
Prototyp: void qsort(void *array, size_t n, size_t size, int (*compare)());
Rückgabewert: keiner
Beschreibung: Sortiert das Feld array aufsteigend mit dem Quick-Sort-Algorithmus, wobei das Feld n Elemente der Größe size besitzt. size_t ist in stdlib.h als unsigned int definiert. compare ist ein Zeiger auf eine Vergleichsfunktion, der Zeiger auf 2 Feldelemente übergeben werden (Argumente von compare müssen Zeiger auf den Typ der Feldelemente sein). compare liefert Rückgabewerte folgender Art:
  • kleiner 0 : 1. Element < 2. Element
  • gleich 0 : 1. Element = 2. Element
  • größer 0 : 1. Element > 2. Element
Beispiel:
#define MAX 1000
...

 int intcmp(const void *v1, const void *v2)
   { return (*(int *)v1 - *(int *)v2); }

main()
  {
  int arr[MAX], count, suche, *zgr;
  ...

  /* Sortiert das Array in aufsteigender Reihenfolge. */
  qsort(arr, MAX, sizeof(arr[0]), intcmp);
  ...
  
  }

raise

Bibliothek: #include <signal.h>
Prototyp: int raise(int sig);
Rückgabewert: erfolgreiche Ausführung: 0; andernfalls Wert ungleich 0
Beschreibung: Sendet ein Signal sig zum ausführenden Programm. Ist mit der Funktion signal eine Behandlungsfunktion für die Nummer des Signals festgelegt worden, so wird diese ausgeführt, andernfalls wird die Standardroutine verwendet.

rand

Bibliothek: #include <stdlib.h>
Prototyp: int rand(void);
Rückgabewert: Zufallszahl
Beschreibung: Liefert eine Pseudo-Zufallszahl, die zwischen 0 und RAND_MAX liegt. RAND_MAX ist in stdlib.h definiert und hat mindestens den Wert 32767. Die Initialisierung erfolgt mit srand.

readdir

Bibliothek: #include <dirent.h>
#include <sys/types.h>
Prototyp: struct dirent readdir (DIR *dirp);
Rückgabewert: im Erfolgsfall Zeiger auf eine Stuktur mit dem nächsten Verzeichniseintrag, im Fehlerfall und am Ende des Verzeichnisses NULL-Zeiger
Beschreibung: Liefert einen Zeiger auf eine Stuktur mit dem nächsten Verzeichniseintrag. Nacheinanderfolgende Aufrufe liefern den jeweils folgenden Verzeichniseintrag. Die Struktur dirent hat selbst folgende Einträge:
ini_t d_ino: die Inode-Nummer der Datei/des Verzeichnisses
char d_name[]: der Name der Datei/des Verzeichnisses
Beispiel:
DIR * dp;
struct dirent *entry;
dp = opendir("/var/log/");
while ((entry = readdir(dp)) != NULL)
  {
  printf("*s\n",entry->d_name);
  }
closedir(dp); 

realloc

Bibliothek: #include <stdlib.h>
Prototyp: void *realloc(void *ptr, size_t n);
Rückgabewert: typenloser Zeiger auf zugewiesenen Speicher; im Fehlerfall NULL-Zeiger
Beschreibung: Verändert die Größe des durch ptr bezeichneten Speicherbereichs, der zuvor durch malloc, calloc oder realloc reserviert wurde. n ist die Länge des neuen Speicherbereiches size_t ist in stdlib.h als unsigned int definiert. Die Daten im bereits zugewiesenen Bereich bleiben unverändert.
Beispiel:
realloc(zeiger,anzahl*sizeof(typ));

remove

Bibliothek: #include <stdio.h>
Prototyp: int remove(const char *filename);
Rückgabewert: Im Fehlerfall Wert ungleich 0; andernfalls 0
Beschreibung: Die unter filename angegebene Datei läßt sich nicht mehr unter ihrem Namen ansprechen, verfügt sie über keine weiteren Dateiverweise (Links), so wird sie gelöscht (-> unlink). Verzeichnisse oder read-only-Dateien können nicht gelöscht werden. Bei Fehlern erhält errno den Wert EACCES bzw. ENOENT.
Beispiel:
remove("bsp.txt");
/* löscht die Datei 'bsp.txt' */

rename

Bibliothek: #include <stdio.h>
Prototyp: int rename(const char *altname, const char *neuname);
Rückgabewert: 0; im Fehlerfall Wert ungleich 0
Beschreibung: Benennt die Datei altname in neuname um. altname muß bereits existieren. Eintrag von neuname in ein anderes Verzeichnis ist möglich, nicht jedoch Eintrag in ein anderes Dateisystem (wie das UNIX mv-Kommando).
Beispiel:
rename("/home/meier/bsp.c","/home/meier/src/bsp1.c");

rewind

Bibliothek: #include <stdio.h>
Prototyp: void rewind(FILE *fp);
Rückgabewert: keiner
Beschreibung: Setzt den Seek-Zeiger der Datei auf den Dateianfang zurück, löscht das Dateiende-Flag und das Fehler-Flag
Beispiel:
rewind(fp);

scanf

Bibliothek: #include <stdio.h>
Prototyp: int scanf(const char *formatstring,...,

[arg1,...,argn]);

Rückgabewert: Anzahl der tatsächlich eingelesenen und konvertierten Eingabefelder; bei Lesefehler oder Dateiende: EOF
Beschreibung: Liest Zeichen in formatierter Form von der Standardeingabe stdin ein und legt sie konvertiert in den Argumenten arg1 bis argn ab. Die Interpretation der eingelesenen Zeichen erfolgt durch den Format-String formatstring.
Für jedes Formatelement des Strings muß ein Argument angegeben sein (überzählige werden ignoriert). Die Formatelemente haben folgende Form:

% [Feldbreite] Typ (siehe auch printf).

Eingabefelder werden durch Leerzeichen getrennt

  • wird mit Typ s ein String eingelesen, so wird ein Stringende-Zeichen angehängt
  • anstelle von s kann auch ein Scanset (Folge von sog. Suchzeichen) angegeben werden, welcher in eckige Klammern eingeschlossen wird; jedes einzulesende Zeichen muß dann mit einem der Suchzeichen übereinstimmen. Ist den Suchzeichen ein '^' vorangestellt, wird das Einlesen beendet, sobald ein Suchzeichen auftritt.
  • steht hinter '%' ein '*', wird das entsprechende Eingabefeld überlesen. Es darf kein Argument angegeben werden.

seekdir

Bibliothek: #include <dirent.h>
#include <sys/types.h>
Prototyp: void seekdir (DIR *dirp, long int pos);
Rückgabewert: -
Beschreibung: Setzt im Verzeichnis-Stream den Positionszeiger auf die durch pos gegebene Stelle. Der Wert von pos wird durch einen vorhergehenden Aufruf von telldir ermittelt. Man kann sich so eine Stelle beim sequentiellen Lesen eines Verzeichnisses merken und später dorthin zurückspringen.
Beispiel:
pos = telldir(dir);
/* ... */
seekdir(dir,pos); 

setbuf

Bibliothek: #include <stdio.h>
Prototyp: void setbuf(FILE *fp, char *buffer);
Rückgabewert: keiner
Beschreibung: Richtet für die mit dem Dateizeiger verbundene Datei den Dateipuffer buffer mit Länge BUFSIZ ein. BUFSIZ ist in stdio.h definiert. Falls buffer ein NULL-Zeiger ist, ist die Ein-/Ausgabe ungepuffert. setbuf muß sofort nach dem Öffnen der Datei aufgerufen werden.
Beispiel:
char puffer[BUFSIZ];
setbuf(fp,puffer);

setjmp

Bibliothek: #include <setjmp.h>
Prototyp: int setjmp(jmp_buf env);
Rückgabewert: 0; bei Rücksprung durch longjmp wird dieser auf einen Wert ungleich 0 gesetzt
Beschreibung: Speichert den momentanen Maschinenzustand und die Stack-Umgebung in env. jmp_buf ist in setjmp.h definiert. Durch späteren longjmp-Aufruf wird der gespeicherte Zustand wiederhergestellt.
Beispiel:
setjmp(env); 

setvbuf

Bibliothek: #include <stdio.h>
Prototyp: int setvbuf (FILE *fp,char *buf,int mode,size_t size);
Rückgabewert: Im Fehlerfall Wert ungleich 0; sonst: 0
Beschreibung: Legt für die Datei anstelle des standardmäßigen Dateipuffers einen Puffer der Länge size. Für den Parameter mode sind in stdio.h folgende symbolische Konstanten definiert:

_IOFBF: Ein-/Ausgabe werden vollständig gepuffert
_IOLBF: Ausgaben werden zeilenweise gepuffert, Eingaben werden vollständig gepuffert
_IONBF: Ein-/Ausgaben sind ungepuffert

Falls buffer ein NULL-Zeiger ist, so wird durch einen Aufruf von malloc ein Puffer der Größe size dynamisch angelegt

Beispiel:
setvbuf(fp,buffer,_IONBF,sizeof(buffer);
/* setzt für die mit fp verbundene Datei 
ungepufferte Ein-/Ausgabe (buffer und 
sizeof(buffer) werden ignoriert) */

signal

Bibliothek: #include <signal.h>
Prototyp: void (*signal (int sig, void (*func)(int)))(int);
Rückgabewert: Im Fehlerfall SIG_ERR; beim erster Aufruf SIG_DFL; sonst den Wert von func aus dem vorhergehenden Aufruf.
Beschreibung: Legt fest, wie das Programm auf Signale mit der Signalnummer sig reagiert. Das Argument func legt die Art der Reaktion fest. Folgende Möglichkeiten sind vorhanden:
  • SIG_DFL: Standardroutine (default) für die Signalnummer wird aufgerufen; danach im allgemeinen Programmende
  • SIG_IGN: Signal wird ignoriert, das Programm fortgesetzt
  • Adresse einer Funktion: signal(sig,SIG_DFL) wird aufgerufen, dann die Funktion (*func)(sig) (für nächstes sig wird die Standardroutine eingesetzt, dann die eigentliche Reaktion auf das momentane Signal ausführt).
Folgende Signaltypen sind nach ANSI-Standard in signal.h definiert:
  • SIGABRT: abnormale Programmbeendigung (z.B. durch abort; Beenden des Programms)
  • SIGHUB: Programmbeendigung durch Elternprozess
  • SIGFPE: Divisions-,Coprozessor- oder Emulationsfehler
  • SIGINT: durch Drücken von Ctrl-C
  • SIGSEGV: durch ungültigen Speicherzugriff
  • SIGTERM: Software-Beendigung des Programms (unter UNIX Standardsignal des Kill-Kommandos)
Bei Fehlern erhält errno den Wert EINVAL.
Beispiel:
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
void sig_handler(int sig);
main()
  {
  if (signal(SIGINT,sig_handler) == SIGERR)
    { perror("Signal-Funktion"); exit(3); }
  for(;;) /* forever */ 
    puts("Abbruch mit Strg-C!\n");
  }

void sig_handler(int sig)
  {
  char c;
  if (sig != SIGINT) exit(1);
  signal(SIGINT,SIG_IGN);
  fputs("\nProgramm beenden(j/n)?",stderr);
  while((c = toupper(getchar())) != 'J' && c != 'N');
  if(c == 'J') exit(0);
  signal(SIGINT,sig_handler);
  }

sin

Bibliothek: #include <math.h>
Prototyp: double sin(double x);
Rückgabewert: sin(x)
Beschreibung: Liefert den Sinus von x. Die Angabe erfolgt im Bogenmaß. Das Argument x wird durch Modulo-Division in den Bereich von 0 bis 2*Pi umgerechnet (Ungenauigkeit bei großen Argumenten).
Beispiel:
printf("sin(0.0) = %4.1f\n", sin(0.0));
/* Ausgabe: sin(0.0) = 0.0 */

sinh

Bibliothek: #include <math.h>
Prototyp: double sinh(double x);
Rückgabewert: sinh(x); bei Überlauf: HUGE_VAL
Beschreibung: Liefert den Sinus Hyperbolicus von x. Bei einem Überlauf erhält errno den Wert ERANGE.
Beispiel:
printf("sinh(0.0) = 8.4f\n",sinh(0.0));
/* Ausgabe: sinh(0.0) = 0.0000 */

sprintf

Bibliothek: #include <stdio.h>
Prototyp: int sprintf(char *string,const char *formatstring, [arg1,...,argn]);
Rückgabewert: Anzahl der Zeichen, die in den String kopiert wurden (ohne Stringende-Zeichen)
Beschreibung: Kopiert entsprechend dem formatstring mit den Werten aus der Argumentliste formatiert in den String string (Stringende-Zeichen wird angehängt). Arbeitsweise wie printf, jedoch ist das Zeil der Ausgabe keine Datei, sondern ein String.
Beispiel:
sprintf(text,"%15s %20s",vorname,name);

sqrt

Bibliothek: #include <math.h>
Prototyp: double sqrt(double x);
Rückgabewert: Quadratwurzel von x
Beschreibung: Liefert die Quadratwurzel von x. Falls x negativ ist, erhält errno den Wert ERANGE
Beispiel:
printf("sqrt(9) = %f\n",sqrt(9));
/* Ausgabe: sqrt(9) = 3.0 */

srand

Bibliothek: #include <stdlib.h>
Prototyp: void srand(unsigned n);
Rückgabewert: keiner
Beschreibung: Initialisiert den Zufallszahlengenerator mit n; anschließend erzeugt rand eine neue Folge von Zufallszahlen
Beispiel:
srand(5); /* initialisiert den Generator mit 5 */

sscanf

Bibliothek: #include <stdio.h>
Prototyp: int sscanf(char *string,const char *formatstring, ... [arg1,...,argn]);
Rückgabewert: Anzahl der tatsächlich übertragenen Eingabefelder; Stringende-Zeichen : EOF
Beschreibung: Liest und konvertiert Daten aus dem String string und schreibt sie in die durch die Argumentliste bezeichneten Variablen
Beispiel:
sscanf(adresse,"%[^,],%[^,],%d",ort, straße, &hausnr);
/* liest aus dem String adresse:
1. Teilstring (bis zu einem Komma) in  ort, 
2. Teilstring (bis zu einem Komma) in straße 
und den Rest (eine Zahl) in hausnr */

strcat

Bibliothek: #include <string.h>
Prototyp: char *strcat(char *s1,const char *s2);
Rückgabewert: erstes Argument
Beschreibung: Kettet den String s2 an das Ende des Strings s1 (Stringende-Zeichen von s1 wird überschrieben). s1 muß s2 aufnehmen können.
Beispiel:
strcat(s1,s2); /* hängt s2 an s1 an */

strchr

Bibliothek: #include <string.h>
Prototyp: char *strchr(const char *s,int c);
Rückgabewert: Zeiger auf Stelle des 1. Auftretens von c im String s; nicht vorhanden: NULL-Zeiger
Beschreibung: Sucht nach dem 1. Auftreten des Zeichens c im String s
Beispiel:
P = strchr(text,'.');
/* sucht im String text nach dem ersten 
Auftreten eines Punktes */

strcmp

Bibliothek: #include <string.h>
Prototyp: int strcmp(const char *s1,const char *s2);
Rückgabewert: < 0: s1 kleiner s2
= 0: s1 gleich s2
> 0: s1 größer s2
Beschreibung: Vergleicht die Strings s1 und s2 lexikographisch
Beispiel:
x = strcmp("HALLO","hallo");
/* Ergebnis: x = -32 
(da in ASCII die Kleinbuchstaben 
höheren Code haben) */

strcpy

Bibliothek: #include <string.h>
Prototyp: char *strcpy(char *s1,const char *s2);
Rückgabewert: s1
Beschreibung: Kopiert s2 in den von s1 adressierten Speicher
Beispiel:
/* kopiert s2 in den Speicher von s1 */
strcpy(s1,s2);

strcspn

Bibliothek: #include <string.h>
Prototyp: int strcspn(const char *s1,const char *s2);
Rückgabewert: Länge des Teilstrings
Beschreibung: Liefert Länge des Teilstrings von s1, der keines der Zeichen von s2 enthält
Beispiel:
x = strnspn("Das Ergebnis ist 5","0123456789");

strerror

Bibliothek: #include <string.h>
Prototyp: char *strerror(int errnr);
Rückgabewert: Zeiger auf Fehlermeldung
Beschreibung: Liefert einen Zeiger auf die zur Zahl errnr gehörende Systemfehlermeldung zurück. Die Zahl errnr ist meist der in errno gespeicherte Wert.
Beispiel:
fehlertext = strerror(42);
/* Ausgabe: 
   'Protocol driver not attached' */

strlen

Bibliothek: #include <string.h>
Prototyp: size_t strlen(const char *s);
Rückgabewert: Länge des Strings
Beschreibung: Liefert die Länge des Strings s (ohne Stringende-Zeichen). size_t ist in string.h als unsigned int definiert.
Beispiel:
x = strlen("Beispiel");
/* Ergebnis: x = 8 */

strncat

Bibliothek: #include <string.h>
Prototyp: char *strncat(char *s1, const char *s2, size_t n);
Rückgabewert: s1
Beschreibung: Hängt die ersten n Zeichen des Strings s2 und das Stringende-Zeichen an den String s1 an. size_t ist in string.h als unsigned int definiert.
Beispiel:
char s1[20] = "Hello ";
char s2[10] = "Worldwide";
strncat(s1,s2,5);
/* Ergebnis: 'Hello World' */

strncmp

Bibliothek: #include <string.h> NT FACE="Courier" SIZE=2> int strncmp(const char *s1,const char *s2,size_t n);
Rückgabewert: < 0 falls s1 < s2;
= 0 falls s1 = s2
> 0 falls s1 > s2
Beschreibung: Vergleicht die ersten n Zeichen von s1 und s2. Der Vergleich wird beim ersten Stringende-Zeichen abgebrochen
Beispiel:
strncmp(s1,s2,10);

strncpy

Bibliothek: #include <string.h>
Prototyp: char *strncpy(char *s1,const char *s2, size_t n);
Rückgabewert: s1
Beschreibung: Kopiert die ersten n Zeichen von s2 in den durch s1 bezeichneten Speicherbereich. Das Stringende-Zeichen wird nicht angehängt. Ist s2 kleiner als n wird mit '\0' aufgefüllt.
Beispiel:
strncpy(s1,"Testphase",4);

strpbrk

Bibliothek: #include <string.h>
Prototyp: char *strpbrk(const char *s1,const char *s2);
Rückgabewert: Zeiger auf erstes in s1 mit s2 übereinstimmendes Zeichen
Beschreibung: Durchsucht s1 nach einem der in s2 enthaltenen Zeichen.
Beispiel:
zeiger = strpbrk("Blumenweg 3","1234567890");
/*                   zeiger ^              */

strrchr

Bibliothek: #include <string.h>
Prototyp: char *strrchr(const char *s,int c);
Rückgabewert: Zeiger auf letztes Auftreten von Zeichen c in String s; falls c in s nicht vorkommt, der NULL-Zeiger.
Beschreibung: Sucht nach letztem Auftreten des Zeichens c im String s
Beispiel:
P = strchr(text,'.');
/* sucht im String text nach dem letzten 
Auftreten eines Punktes */

strcspn

Bibliothek: #include <string.h>
Prototyp: int strspn(const char *s1,const char *s2);
Rückgabewert: Länge des Teilstrings aus s1, der nur Zeichen aus s2 enthält
Beschreibung: Ermittelt Länge des Teilstrings von s1, der nur aus in s2 enthaltenen Zeichen besteht.
Beispiel:
laenge = strspn("4500 Naegel","1234567890");
/* Ergebnis: laenge = 4 */

strstr

Bibliothek: #include <string.h>
Prototyp: char *strstr(const char *s1,const char *s2);
Rückgabewert: Adresse des ersten Auftretens; ist s2 in s1 nicht enthalten: NULL-Zeiger
Beschreibung: Sucht im String s1 nach s2
Beispiel:
puts(strstr("Heute ist es sehr heiß","sehr"));
/* gibt 'sehr heiß' aus */

strtod

Bibliothek: #include <stdlib.h>
Prototyp: double strtod(const char *s,char **endptr);
Rückgabewert:
  • umgewandelte double-Zahl
  • keine Umwandlung: 0
  • Überlauf: +/- HUGE_VAL
  • Unterlauf: 0
Beschreibung: Wandelt führende Zeichenfolge im String s in eine double-Zahl um; beim ersten nicht als Teil einer Gleitpunktzahl interpretierbaren Zeichen wird die Umwandlung abgebrochen. endptr wird auf das erste nicht mehr interpretierbare Zeichen gesetzt. Bei Über- bzw. Unterlauf erhält errno den Wert ERANGE.
Beispiel:
printf("Zahl: %f\n",strtod("200,5 Km",&rest));
/* Ausgabe: Zahl: 200.5; rest zeigt auf 'Km' */

strtok

Bibliothek: #include <string.h>
Prototyp: char *strtok(char *s1,const char *s2);
Rückgabewert: Zeiger auf das nächste Token; kein weiteres Token: NULL-Zeiger
Beschreibung: Zerlegt String s1 in Token, die durch Zeichen aus s2 voneinander getrennt sind. Beim ersten Aufruf muß s1 angegeben werden, bei jedem weiteren dagegen 0. An jedes Token wird das Stringende-Zeichen '\0' angehängt (s1 wird verändert!). s2 kann bei jedem Aufruf verändert werden.
Beispiel:
zeiger1 = strtok("Hallo, wie geht es"," ");
zeiger2 = strtok(0," ");
/* zeiger1 zeigt auf 'Hallo,' 
   zeiger2 zeigt auf 'wie' */

strtol

Bibliothek: #include <stdlib.h>
Prototyp: long strtol(const char *s,char **endptr,int base);
Rückgabewert:
  • umgewandelte long-Zahl
  • keine Umwandlung: 0;
  • Überlauf: LONG_MIN bzw. LONG_MAX
Beschreibung: Die Zeichenfolge s wird in eine long-Zahl konvertiert; die Zeichenfolge wird als Zahl zur Basis base interpretiert. Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung beendet. endptr zeigt auf das erste nicht interpretierbare Zeichen bei einem Überlauf erhält errno den Wert ERANGE.
Beispiel:
x = strtol(10 Prozent",&rest,10);
printf("***%ld*** %s\n",x,rest);
/* Ausgabe: ***10*** Prozent */

strtoul

Bibliothek: #include <stdlib.h>
Prototyp: unsigned long strtoul(const char *s,char **endptr,int base);
Rückgabewert: umgewandelte unsigned long-Zahl; keine Umwandlung: 0; Überlauf: ULONG_MAX
Beschreibung: Wandelt die Zeichenfolge s in eine unsigned long-Zahl um (Zahl zur Basis base). Beim ersten nicht interpretierbaren Zeichen wird die Umwandlung beendet endptr zeigt auf das erste nicht mehr interpretierbare Zeichen bei einem Überlauf erhält errno den Wert ERANGE.
Beispiel:
x = strtoul("2000 Autos",&rest,10)
printf("Zahl : %ld\n", x);
/* Ausgabe: 2000; rest zeigt auf den Reststring 'Autos' */

system

Bibliothek: #include <stdlib.h>
Prototyp: int system(const char *s);
Rückgabewert:
  • NULL-Zeiger: Kommandointerpreter nicht verfügbar
  • 0 bei korrekter Ausführung
  • ungleich 0 bei einem Fehler
Beschreibung: Erzeugt eine Shell als Kindprozess und führt dort den Strings als Kommando des Betriebssystems aus. Die Bearbeitung erfolgt also wie ein am Prompt eingegebener Befehl. Der Befehl sollte immer als vollständiger Pfad angegeben werden.
Beispiel:
system("/bin/ls -l");
/* Ausgabe des aktuellen Verzeichnisses */

tan

Bibliothek: #include <math.h>
Prototyp: double tan(double x);
Rückgabewert: tan(x); Argumentwert zu groß oder zu nah an den Polstellen: 0
Beschreibung: Liefert den Tangens von x. Die Angabe erfolgt im Bogenmaß.
Beispiel:
printf("tan(1.0) = %7.4f\n",tan(1.0));
/* Ausgabe: tan(1.0) = 1.5574 */

tanh

Bibliothek: #include <math.h>
Prototyp: double tanh(double x);
Rückgabewert: tanh(x)
Beschreibung: Liefert den Tangens Hyperbolicus von x
Beispiel:
printf("tanh(2.0) = %7.4f\n",tanh(2.0));
/* Ausgabe: tanh(2.0) = 0.9640 */

telldir

Bibliothek: #include <dirent.h>
#include <sys/types.h>
Prototyp: long int telldir (DIR *dirp);
Rückgabewert: aktuelle Position im Verzeichnis-Stream.
Beschreibung: Liest im Verzeichnis-Stream den aktuellen Positionszeiger pos. Man kann sich so eine Stelle beim sequentiellen Lesen eines Verzeichnisses merken und später mittels seekdir() dorthin zurückspringen.
Beispiel:
pos = telldir(dir);
/* ... */
seekdir(dir,pos); 

time

Bibliothek: #include <time.h>
Prototyp: time_t time(time_t *ptr);
Rückgabewert: Anzahl der Sekunden
Beschreibung: Liefert Anzahl der Sekunden seit der UNIX-Epoche (1.1.1970 0 Uhr GMT). Die Anzahl wird als Return-Wert zurückgeliefert und gleichzeitig in den durch ptr adressierten Speicher geschrieben. time_t ist in time.h als long definiert.
Beispiel:
time(&zeit);
/* speichert die Anzahl der Sekunden 
seit dem 1.1.1970 0 Uhr in zeit */

tmpfile

Bibliothek: #include <stdio.h>
Prototyp: FILE *tmpfile(void)
Rückgabewert: Falls die Datei erfolgreich eröffnet wurde, der File-Pointer, sonst NULL-Zeiger.
Beschreibung: Öffnet eine temporäre Datei im Binärmodus zum Schreiben und Lesen. Diese Datei wird automatisch bei Programmende oder beim Schließen gelöscht.
Beispiel:
fp = tmpfile();

tmpnam

Bibliothek: #include <stdio.h>
Prototyp: char *tmpnam(char *s);
Rückgabewert: Argument ist NULL-Zeiger: Zeiger auf den internen Puffer mit dem neuen Dateinamen Argument kein NULL-Zeiger: Zeichenkette s
Beschreibung: Liefert einen neuen Dateinamen für eine temporäre Datei (verschieden von allen Dateinamen im aktuellen Verzeichnis). Ist s ein NULL-Zeiger, wird der erzeugte Dateiname in einem internen statischen Puffer abgelegt, der bei jedem neuen Aufruf überschrieben wird. Ist s kein NULL-Zeiger, so muß s auf einen char-Vektor zeigen, der mindestens L_tmpnam Bytes speichern kann (für Dateiname). Es können bis zu TMP_MAX verschiedene Namen erstellt werden. Die symbolischen Konstanten TMP_MAX und L_tmpnam sind in stdio.h definiert.
Beispiel:
tmpnam(name);

tolower

Bibliothek: #include <ctype.h>
Prototyp: int tolower(int c);
Rückgabewert: umgewandeltes Zeichen
Beschreibung: Konvertiert den in c gespeicherten Großbuchstaben in einen Kleinbuchstaben. Jedes andere Zeichen bleibt unverändert (nur ASCII-Zeichen 0 bis 127 betrachtet).
Beispiel:
gross = 'X';
klein = tolower(gross);
/* Ergebnis: 'x' */

toupper

Bibliothek: #include <ctype.h>
Prototyp: int toupper(int c);
Rückgabewert: umgewandeltes Zeichen
Beschreibung: Konvertiert den in c gespeicherten Kleinbuchstaben in einen Großbuchstaben. Andere Zeichen bleiben unverändert (nur ASCII-Zeichen 0 - 127 betrachtet).
Beispiel:
klein = 'h';
gross = toupper(klein);
/* Ergebnis: 'H' */

ungetc

Bibliothek: #include <stdio.h>
Prototyp: int ungetc(int c, FILE *fp);
Rückgabewert: Zeichen c; Fehlerfall : EOF
Beschreibung: Schreibt das Zeichen c wieder in den Dateipuffer zurück. Sollte ein EOF-Flag gesetzt sein, wird dieses gelöscht. Die nachfolgende Leseoperation beginnt mit dem Zeichen c. Die Datei muß zum Lesen geöffnet sein.
Beispiel:
ungetc(c,fp);

va_arg

Bibliothek: #include <stdarg.h>
Prototyp: type va_arg(va_list argptr,type);
Rückgabewert: nächstes Argument
Beschreibung: Ermöglicht Umgang mit variabler Anzahl von Argumenten bei Funktionsaufrufen. Übergibt das nächste optionale Argument der Funktion, auf die argptr zeigt. Dazu muß der Datentyp type des Argumentes angegeben werden.
Beispiel: siehe va_start

va_end

Bibliothek: #include <stdarg.h>
Prototyp: void va_end(va_list argptr);
Rückgabewert: keiner
Beschreibung: Ermöglicht Umgang mit variabler Anzahl von Argumenten bei Funktionsaufrufen. Wird aufgerufen, wenn alle optionalen Argumente einer Funktion gelesen wurden. argptr wird auf 0 gesetzt.
Beispiel: siehe va_start

va_start

Bibliothek: #include <stdarg.h>
Prototyp: void va_start(va_list argptr,lastfix);
Rückgabewert: keiner
Beschreibung: Ermöglicht Umgang mit variabler Anzahl von Argumenten bei Funktionsaufrufen. Initialisiert den Zeiger argptr (zeigt auf erstes optionales Argument). lastfix muß der letzte obligate Parameter sein.
Beispiel:
float durchschnitt(int anz, ...)
   {
   int count, gesamt = 0;
   va_list arg_ptr;

   va_start(arg_ptr, anz);
   for (count = 0; count < anz; count++)
     gesamt += va_arg( arg_ptr, int );
   va_end(arg_ptr);
   return ((float)gesamt/anz);
   }

int main(void)
  {
  float x;
  x = durchschnitt(10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
  printf("DerDurchschnittswert beträgt %f.\n", x);
  return(0);
  }

vfprintf

Bibliothek: #include <stdio.h>
Bibliothek: #include <stdarg.h>
Prototyp: int vfprintf(FILE *fp,const char *formatstring, va_list argptr);
Rückgabewert: Anzahl der ausgegebenen Zeichen
Beschreibung: Entspricht der Funktion fprintf mit dem Unterschied, daß statt der Argumentenliste ein Zeiger auf diese erwartet wird.
Beispiel: siehe fprintf

vprintf

Bibliothek: #include <stdio.h>
Bibliothek: #include <stdarg.h>
Prototyp: int vprintf(const char *formatstring, va_list argptr);
Rückgabewert: Anzahl der ausgegebenen Zeichen
Beschreibung: Entspricht der Funktion printf mit dem Unterschied, daß statt der Argumentenliste ein Zeiger auf diese erwartet wird
Beispiel: siehe printf

vsprintf

Bibliothek: #include <stdio.h>
Bibliothek: #include <stdarg.h>
Prototyp: int vsprintf(char *buf, const char *formatstring, va_list argptr);
Rückgabewert: Anzahl der ausgegebenen Zeichen
Beschreibung: Entspricht der Funktion sprintf mit dem Unterschied, daß statt der Argumentenliste ein Zeiger auf diese erwartet wird
Beispiel: siehe printf

Zum Inhaltsverzeichnis Zum nächsten Abschnitt


Copyright © FH München, FB 04, Prof. Jürgen Plate