C-Funktionen
Beschreibung der C-Funktionen in Aufbau und
Anwendung
- Anwenderhandbuch -
für
C - Programmierung
Dipl.-Ing. Siegfried Meyer (†)
Dr. Stefano Ianigro
Universität der Bundeswehr Hamburg
14. Februar 2022
1
Das Handbuch enthält Informationen über C - Funktionen der verschiedenen C - Derivate mit Hinweisen zur Anwendung.
Zusammenfassung
Schriftenreihe zur C-Programmierung
Inhaltsverzeichnis
1
Einleitung
3
2
C-Präprozessor
5
2.1
#include-Direktive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.2
Symbolische Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
2.3
Makro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
2.4
Bedingte Übersetzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
2.4.1
Beispiel - Bedingte Übersetzung - . . . . . . . . . . . . . . . . . . . .
8
Wichtige Include-Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.5
3
Bibliotheksroutinen
11
3.1
Bibliotheksroutinen - Übersicht . . . . . . . . . . . . . . . . . . . . . . . . .
12
3.1.1
Klassifizierungsroutinen - ASCII-Zeichen . . . . . . . . . . . . . . .
12
3.1.2
Konvertierungsroutinen . . . . . . . . . . . . . . . . . . . . . . . . .
13
3.1.3
Verzeichnisroutinen . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
3.1.4
Diagnoseroutinen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
3.1.5
I/O-Routinen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
3.1.6
DOS/8086/BIOS-Routinen . . . . . . . . . . . . . . . . . . . . . . .
15
3.1.7
String- und Speichermanipulation . . . . . . . . . . . . . . . . . . .
16
3.1.8
Mathematische Routinen . . . . . . . . . . . . . . . . . . . . . . . .
17
3.1.9
Dynamische Verwaltung des Speichers . . . . . . . . . . . . . . . .
18
3.1.10 Diverses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18
3.1.11 Prozeßroutinen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18
3.1.12 Standardroutinen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
3.1.13 Datum und Uhrzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
3.1.14 Variable Argumente . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
1
2
4
INHALTSVERZEICHNIS
Funktionen
21
4.1
abort() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
4.2
abs() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
4.3
acos() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24
4.4
asctime() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
4.5
asin() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
28
4.6
assert() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
30
4.7
atan() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
4.8
atan2() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
34
4.9
atexit() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
4.10 atof() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
38
4.11 atoi() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
40
4.12 atol() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
42
4.13 bsearch() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
44
4.14 calloc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
46
4.15 ceil() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
48
4.16 chdir() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
50
4.17 chmod() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
52
4.18 clearerr() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
54
4.19 clock() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
55
4.20 close() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
56
4.21 cos() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
58
4.22 cosh() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
60
4.23 creat() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
61
4.24 ctime() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
63
4.25 difftime() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
65
4.26 disable() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
67
4.27 div() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
69
4.28 ecvt() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
70
4.29 enable() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
72
4.30 exit() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
74
INHALTSVERZEICHNIS
3
4.31 exp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
76
4.32 fabs() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
78
4.33 fclose() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
79
4.34 feof() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
81
4.35 ferror() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
83
4.36 fflush() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
85
4.37 fgetc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
87
4.38 fgetpos() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
89
4.39 fgets() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
91
4.40 fileno() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
93
4.41 floor() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
94
4.42 flushall() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
95
4.43 fmod() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
96
4.44 fopen() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
97
4.45 fprintf() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
99
4.46 fputc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
4.47 fputs() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
4.48 fread() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
4.49 free() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
4.50 freopen() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
4.51 frexp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
4.52 fscanf() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
4.53 fseek() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
4.54 fsetpos() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
4.55 ftell() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
4.56 fwrite() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
4.57 geninterrupt() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
4.58 getc(), getchar() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
4.59 getcbrk() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
4.60 getch(), getche() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
4.61 getcurdir() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
4
INHALTSVERZEICHNIS
4.62 getcwd() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
4.63 getdate() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
4.64 getdfree() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
4.65 getdisk() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
4.66 getenv() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
4.67 gets() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
4.68 gettime() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
4.69 getvect() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
4.70 gmtime() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
4.71 harderr() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
4.72 hardresume() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
4.73 hardretn() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
4.74 inp(),outp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
4.75 int86(),int86x() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
4.76 intdos() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
4.77 ioctl() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
4.78 isalnum() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
4.79 isalpha() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
4.80 isascii() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
4.81 isatty() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
4.82 iscntrl() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
4.83 isdigit() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
4.84 isgraph() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
4.85 islower() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
4.86 isprint() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
4.87 ispunct() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
4.88 isspace() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
4.89 isupper() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
4.90 isxdigit() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
4.91 itoa() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
4.92 kbhit() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
INHALTSVERZEICHNIS
5
4.93 labs() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
4.94 ldexp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
4.95 ldiv() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
4.96 lfind() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
4.97 localtime() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
4.98 log() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
4.99 log10() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
4.100longjmp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
4.101lseek() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
4.102malloc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
4.103memchr() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
4.104memcmp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
4.105memcpy() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
4.106memmove() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
4.107memset() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
4.108mktime() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
4.109modf() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
4.110open() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
4.111perror() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
4.112pow() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
4.113printf() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
4.114putc(),putchar() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
4.115puts() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
4.116qsort() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
4.117raise() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
4.118rand() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
4.119read() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
4.120realloc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
4.121remove() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
4.122rename() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
4.123rewind() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
6
INHALTSVERZEICHNIS
4.124scanf() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
4.125setbuf() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
4.126setjmp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
4.127setvbuf() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
4.128signal() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
4.129sin() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
4.130sinh() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
4.131spawn...() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
4.132sprintf() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
4.133sqrt() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
4.134srand() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
4.135sscanf() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
4.136stat() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
4.137strcat() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
4.138strchr() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
4.139strcmp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
4.140strcpy() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
4.141strcspn() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
4.142strerror() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
4.143strlen() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
4.144strncat() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
4.145strncmp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
4.146strncpy() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
4.147strpbrk() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
4.148strrchr() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
4.149strspn() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
4.150strstr() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
4.151strtod() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
4.152strtok() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
4.153strtol() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
4.154strtoul() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
INHALTSVERZEICHNIS
7
4.155system() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
4.156tan() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
4.157tanh() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
4.158time() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
4.159tmpfile() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
4.160tmpnam() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
4.161toascii() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
4.162tolower() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
4.163toupper() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
4.164ungetc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
4.165ungetch() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
4.166unlink() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
4.167va arg() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
4.168vfprintf(), vprintf(), vsprintf() . . . . . . . . . . . . . . . . . . . . . . . . . 298
4.169write() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
8
INHALTSVERZEICHNIS
Kapitel 1
Einleitung
Der große Umfang der zur Verfügung stehenden C-Funktionen erfordert für den effizienten Einsatz bei der C-Programmierung eine übersichtliche Dokumentation. Diese Unterlage soll dem C-Programmierer als Hilfsmittel für die Programmierarbeit dienen, indem
die wichtigsten C-Funktionen in ihrer Funktionalität beschrieben werden. Die Syntax der
einzelnen Funktionen mit ihrer Aufrufsequenz bilden dabei den grundsätzlichen Rahmen der Beschreibung. Aus den zusätzlichen Erläuterungen kann der Anwender weitere
wichtige Informationen zur Anwendung entnehmen. Die Hinweise dienen den anwendungsorientierten Problemstellungen und leisten einen Beitrag zum besseren Verständnis für den Einsatz der jeweiligen Funktion. Hierbei werden im wesentlichen die Leistungskriterien mit den Restriktionen und möglichen Fehlermeldungen beschrieben.
Die Unterlage enthält alle wesentlichen Funktionen nach dem ANSI - Standard (sind bei
der Funktionserklärung mit ANSI gekennzeichnet) mit zusätzlichen nützlichen Funktionen. Durch den Einsatz der ANSI - Funktionen ist eine gute Voraussetzung für die
Portabilität der Programme gegeben und sollte immer berücksichtigt werden !
Zu jeder der aufgeführten Funktionen ist für die praktische Anwendung ein lauffähiges
Beispiel angegeben, welches zum Testen auf dem IBM-PC (BORLAND C++ 3.1) direkt
eingesetzt werden kann. Viele der vorliegenden Beispiele wurden auch unter UNIX erfolgreich getestet.
Damit der C-Programmierer sich auf das Wesentliche konzentrieren kann, sind alle angegebenen Beispiele auf einer Diskette verfügbar.
10
KAPITEL 1. EINLEITUNG
Kapitel 2
C-Präprozessor
In vielen Programmen ist es sinnvoll, symbolische Namen für Konstanten zu verwenden. Unter Verwendung eines mnemotechnischen Namens ist oftmals eine bessere
Programmentwicklung möglich. C bietet diese Möglichkeit in Form eines Makro-Präprozessors, der automatisch vor dem Kompilieren gestartet wird.
Die Anweisungen für den Präprozessor werden durch das # in der 1. Spalte eingeleitet.
Folgende Präprozessoranweisungen sind einsetzbar:
• Einfügen von include - Dateien
• Definition von symbolischen Konstanten
• Definition von Makros
• Bedingte Compilierung
2.1
#include-Direktive
Durch die #include-Direktive wird die durch dateiname spezifizierte Datei in das Programm kopiert.
Syntax
Beispiel
:
#include “dateiname“
#include <dateiname>
:
#include “messwert“
#include <stdio.h>
Das Einbinden der durch dateiname spezifizierten Datei erfolgt nach folgender Konvention:
12
KAPITEL 2. C-PRÄPROZESSOR
Zeichen
< ... >
“. . .“
Bedeutung
Die Datei wird nur in der Directory
gesucht, welche durch die Umgebungsvariable INCLUDE festgelegt wurde.
Die Datei wird zuerst im aktuellen
Directory und nachfolgend in der durch
INCLUDE festgelegten Directory gesucht.
Enthält dateiname eine Pfadangabe, so wird nur im angegebenen Directory gesucht.
Für die variable Programmierung kann der Dateiname auch als symbolische Konstante
definiert werden.
:
Beispiel
#include <stdio.h>
#include “messwert.h“
#define VERSION “version1.h“
#include VERSION
2.2
Symbolische Konstanten
Mit Hilfe von symbolischen Konstanten können variable und übersichtliche Programme
entwickelt werden. Konstanten können am Programmanfang übersichtlich definiert und
bei Bedarf leicht verändert werden.
Syntax
:
Beispiele
#define name Ersatztext
:
#define ANZ 1024
#define ESC \033
#define PI 3.14159265
Der Präprozessor ersetzt z.B. automatisch in dem nachfolgenden Programmtext ANZ
durch 1024, wobei der Ersatztext eine Zeichenkette ist. Durch diesen Mechanismus
können auch Funktionsnamen ersetzt werden. Die Fortsetzungszeile wird durch das Zeichen \ erzeugt.
2.3
Makro
Eine Erweiterung zu der Vereinbarung von symbolischen Konstanten ist die Definition
eines Makros.
Syntax
:
#define makroname(para1, para2, . . . ) Ersatztext
2.4. BEDINGTE ÜBERSETZUNG
Beispiele
:
#define MAX(x,y) ((x) > (y) ? (x):(y))
#define CLS printf(“\033 [2J“)
13
(DOS !!)
Da Makros keine Funktionen sind, benötigen sie keinen Funktionsnamen und keine
Rücksprungvereinbarung. Sie werden nur an den entsprechenden Stellen durch den
Compiler ersetzt !
2.4
Bedingte Übersetzung
Für die Entwicklung von Programmen für unterschiedliche Systeme kann die Möglichkeit der bedingten Übersetzung eingesetzt werden. Mit Hilfe von Direktiven können
Teile eines Programms durch Setzen von Steuerungsvariablen gezielt übersetzt werden.
Hierfür stehen folgende Möglichkeiten zur Verfügung:
Syntax
:
#if ausdruck
#ifdef name
#else
#elif
#endif
#undef ausdruck2
14
KAPITEL 2. C-PRÄPROZESSOR
#if ausdruck
:
wertet ausdruck aus. Ist der Wert wahr,
also ein Wert verschieden von 0, so erfolgt
die Bearbeitung des abhängigen Textes.
#ifdef name
stellt fest, ob name zuvor mit #define
vereinbart wurde. Erfolgte eine Vereinbarung, wird der
entsprechende Programmteil compiliert.
#else
kann bei der if - Bedingung als alternativer Pfad
eingesetzt werden. Sie darf in einer #if - Bedingung
höchstens einmal vorkommen.
#elif
kann in einer if - Bedingung als alternativer Pfad
mehrmals eingesetzt werden.
#endif
schließt einen if - Block ab.
#undef aud2
ausd2 wird zurückgesetzt.
2.4.1
Beispiel - Bedingte Übersetzung -
\#define MCS
main()
{
.......
.......
#ifdef MCS
/* Testblock */
#endif
}
In diesem Beispiel wird der Block MCS übersetzt, da die Variable MCS mittels der
define-Anweisung gesetzt (TRUE) wurde. Für die Programmierung ist zu beachten, daß
eine Verschachtelung von if- Konstruktionen möglich ist, jedoch das # - Zeichen muß
immer in der 1. Spalte gesetzt sein.
2.5. WICHTIGE INCLUDE-DATEIEN
2.5
15
Wichtige Include-Dateien
Datei
alloc.h
malloc.h
assert.h
bios.h
conio.h
ctype.h
dir.h
dos.h
ernno.h
float.h
graphics.h
io.h
limits.h
locale.h
math.h
setjmp.h
signal.h
stdarg.h
stddef.h
stdio.h
stdlib.h
string.h
sys\stat.h
sys\types.h
time.h
Bedeutung
Deklarationen für dynamische Speicherverwaltung.
Deklarationen für dynamische Speicherverwaltung.
Definiert das Makro assert für Prüfung eines Programms.
Deklarationen für die Schnittstelle zu den BIOS-Funktionen.
Deklarationen für die Schnittstelle von BIOS-Funktionen für
Tastatur und Bildschirm.
Definitionen von Makros für die Bearbeitung von Zeichen.
Definitionen von Datentypen, Makros und Funktionen für
Verzeichnisse und Path-Einstellungen.
Definitionen von Datentypen, Makros und Deklaration.
von Schnittstellen für den direkten Aufruf von DOS-Funktionen.
Definitionen symbolischer Konstanten für Fehlernummern.
Definition von Parametern für Gleitkomma-Funktionen.
Prototypen für Grafikfunktionen.
Strukturen und Deklarationen für einfache Ein-und Ausgabe.
Definition von Parametern für die Umgebung, Grenzwerte des
Compilers.
Deklariert Funktionen, die länder- und sprachspezifische
Informationen liefern.
Deklaration mathematischer Funktionen.
Deklaration der Funktionen setjmp,longjmp und definiert
jmp buf für die Ausführung eines nicht lokalen goto.
Deklariert die Funktionen signal, raise mit Konstanten.
Definition der Funktionen mit variabler Parameterübergabe.
Definition einer Anzahl allgemein verwendeter Datentypen und Makros.
Deklaration für Standard Ein-/Ausgabefunktionen.
Deklaration allgemeiner Routinen zur Konvertierung von
Datentypen; Absuche und Sortieren von Arrays.
Deklarationen für Funktionen zur Stringmanipulation.
Definition von symbolischen Konstanten zum Öffnen und
Arbeiten mit Dateien.
Definition des Datentyps time t.
Definition einer Struktur für Zeitumwandlungsroutinen.
16
KAPITEL 2. C-PRÄPROZESSOR
Kapitel 3
Bibliotheksroutinen
17
18
3.1
3.1.1
KAPITEL 3. BIBLIOTHEKSROUTINEN
Bibliotheksroutinen - Übersicht
Klassifizierungsroutinen - ASCII-Zeichen
Überprüfung einzelner ASCII-Zeichen auf z.B. Buchstabe, Steuerzeichen, Interpunktionszeichen, Großschreibung, . . . usw.
Funktion
-
Beschreibung
isalnum
-
Überprüfung alphanumerischer Zeichen. (ANSI)
isalpha
-
Überprüfung alphanumerischer Zeichen. (ANSI)
isascii
-
Überprüfung ASCII-Zeichen. (ANSI)
iscntrl
-
Überprüfung Steuerzeichen. (ANSI)
isdigit
-
Überprüfung Ziffer. (ANSI)
isgraph
-
Überprüfung graphisches Zeichen. (ANSI)
islower
-
Überprüfung Kleinbuchstabe. (ANSI)
isprint
-
Überprüfung druckbares Zeichen. (ANSI)
ispunct
-
Überprüfung Interpunktionszeichen. (ANSI)
isspace
-
Überprüfung Zwischenraum. (ANSI)
isupper
-
Überprüfung Großbuchstabe. (ANSI)
isxdigit
-
Überprüfung Hexadezimal. (ANSI)
3.1. BIBLIOTHEKSROUTINEN - ÜBERSICHT
3.1.2
19
Konvertierungsroutinen
Umwandlungsroutinen für Zeichen und Strings in numerische Werte und umgekehrt,
sowie Umwandlung von Groß- in Kleinbuchstaben und umgekehrt.
Funktion
-
Beschreibung
atof
-
atoi
-
atol
-
ecvt
itoa
strtod
strtol
strtoul
-
toascii
tolower
toupper
-
ASCII TO Float - wandelt eine Zeichenkette in eine
Gleitpunktzahl um. (ANSI)
ASCII TO Integer - wandelt eine Zeichenkette in eine
Integerzahl um. (ANSI)
ASCII TO long - wandelt eine Zeichenkette in einen long-Wert.
(ANSI)
wandelt eine Gleitpunktzahl in eine Zeichenkette. (ANSI)
konvertiert einen Integer-Wert in einen String.
konvertiert einen String in einen double-Wert. (ANSI)
konvertiert einen String in einen long-Wert.(ANSI)
konvertiert einen String in einen unsigned long-Wert.
(ANSI)
Konvertierung von Zeichen in das ASCII-Format.
wandelt Groß- in Kleinbuchstaben um. (ANSI)
wandelt Klein- in Großbuchstaben um. (ANSI)
3.1.3
Verzeichnisroutinen
Routinen für Verzeichnisse (Directory) und Suchwege (Path).
Funktion
-
Beschreibung
chdir
getcurdir
getcwd
getdisk
-
wechselt das aktuell gesetzte Directory.
ermittelt das aktuelle Verzeichnis eines Laufwerkes.
ermittelt das aktuelle Arbeitsverzeichnis eines Laufwerkes.
ermittelt das aktuelle Laufwerk.
3.1.4
Diagnoseroutinen
Test auf Fehler und Behandlung von Laufzeitfehler.
Funktion
-
Beschreibung
assert
perror
matherr
-
überprüft den Ausdruck expression. (ANSI)
gibt Systemfeldermeldung aus. (ANSI)
programmierbare Routine zur Behandlung von Berechnungsfehlern.
20
3.1.5
KAPITEL 3. BIBLIOTHEKSROUTINEN
I/O-Routinen
Allgemeine Eingabe - und Ausgaberoutinen.
Funktion
-
Beschreibung
chmod
clearerr
close
creat
-
fclose
feof
ferror
fflush
fgetc
fgetpos
fgets
fileno
flushall
fopen
fprintf
feof
fputc
fputs
fread
freopen
fscanf
fseek
fsetpos
ftell
fwrite
getc, getchar
getch, getche
gets
ioctl
isatty
kbhit
lseek
open
perror
printf
putc,putchar
puts
-
ändert die Zugriffsrechte einer Datei. (ANSI)
setzt die Fehlerflags einer offenen Datei zurück. (ANSI)
schließt eine Datei.
erzeugt eine neue oder überschreitet eine bereits
vorhandene Datei. (ANSI)
schließt eine Datei.
überprüft, ob das Ende der Datei erreicht wurde. (ANSI)
Fehlerüberprüfung bei Zugriff auf Datei. (ANSI)
Dateipuffer leeren. (ANSI)
liest ein Zeichen aus Datei. (ANSI)
ermittelt die aktuelle Position in der Datei. (ANSI)
liest eine Zeichenkette aus einer Datei. (ANSI)
ermittelt das File-Handle der Datei.
Dateipuffer aller geöffneten Dateien leeren.
eröffnet eine Datei. (ANSI)
schreibt formatiert in eine Datei. (ANSI)
überprüft, ob das Ende der Datei erreicht wurde. (ANSI)
schreibt ein Zeichen in eine Datei. (ANSI)
schreibt eine Zeichenkette in eine Datei. (ANSI)
liest Daten aus einer Datei. (ANSI)
wechselt die Datei. (ANSI)
liest formatiert aus einer Datei. (ANSI)
verschiebt den Dateizeiger in einer Datei. (ANSI)
positioniert den Dateizeiger in einer Datei. (ANSI)
ermittelt den aktuellen Dateizeiger. (ANSI)
schreibt Daten in eine Datei. (ANSI)
liest ein Zeichen aus der Datei. (ANSI)
liest ein Zeichen von Tastatur.
liest eine Zeichenkette von Tastatur. (ANSI)
direkte Steuerung von Peripheriegeräten.
Gerätetyp überprüfen.
überprüft Tastatureingabe.
verschiebt den Schreib-/Lesezeiger.
öffnet eine Datei.
gibt Systemfehlermeldung aus. (ANSI)
gibt formatiert auf dem Bildschirm aus. (ANSI)
gibt ein Zeichen aus.
schreibt eine Zeichenkette auf Bildschirm. (ANSI)
3.1. BIBLIOTHEKSROUTINEN - ÜBERSICHT
21
Ein-Ausgabe-Routinen (Forts.).
Funktion
-
Beschreibung
read
remove
rename
rewind
scanf
setbuf
setvbuf
sprintf
sscanf
stat
strerror
tmpfile
tmpnam
ungetc
ungetch
-
vfprintf
vsprintf
write
-
liest Daten aus Datei.
löscht eine Datei. (ANSI)
ändert den Namen einer Datei von oldname auf newname. (ANSI)
setzt den Dateizeiger auf den Anfang der Datei. (ANSI)
liest formatierte Daten ein. (ANSI)
explizite Pufferzuordnung. (ANSI)
explizite variable Pufferzuordnung. (ANSI)
formatierte Ausgabe in einen String. (ANSI)
liest eine formatierte Eingabe. (ANSI)
ermittelt Status-Informationen einer Datei. (ANSI)
liefert einen Zeiger auf einen String mit Fehlermeldung. (ANSI)
eröffnet eine temporäre Datei im Binär-Modus. (ANSI)
erzeugt eindeutige Namen für temporäre Dateien. (ANSI)
schreibt ein gelesenes Zeichen in eine Datei zurück. (ANSI)
stellt ein gelesenes Zeichen von der Tastatur in den
Tasturpuffer zurück.
formatierte Ausgabe mit Zeiger auf Argumentliste. (ANSI)
formatierte Ausgabe in einen String. (ANSI)
schreibt Daten in eine Datei. (ANSI)
3.1.6
DOS/8086/BIOS-Routinen
Routinen für den direkten Zugriff von DOS-,BIOS-, und hardware-spezifischen Funktionen.
Funktion
-
Beschreibung
disable
enable
geninterrupt
getcbrk
getdfree
getvect
harderr
hardresume
hardretn
int86, int86x
intdos
unlink
-
unterdrückt Hardware-Interrupts.
aktiviert Hardware-Interrupts.
erzeugt einen Software-Interrupt.
ermittelt Ctrl-Break-Flag.
ermittelt den freien Platz auf einer Diskette/Festplatte.
liest einen Interrupt-Vektor.
installiert einen Hardware-Error-Handler.
Hardware-Fehlerbehandlungsroutine.
Hardware-Fehlerbehandlungsroutine.
Genereller 8086-Softwareinterrupt.
allgemeiner DOS-Funktionsaufruf.
löscht eine Datei.
22
3.1.7
KAPITEL 3. BIBLIOTHEKSROUTINEN
String- und Speichermanipulation
Stringverarbeitung - Vergleichen, Kopieren, Verschieben, Suchen.
Funktion
-
Beschreibung
memchr
memcmp
memcpy
memmove
memset
strcat
strchr
strcmp
strcpy
strcspn
-
strerror
-
strlen
strncat
-
strncmp
-
strncpy
strpbrk
-
strrchr
-
strstr
strtok
-
sucht Zeichen im String. (ANSI)
vergleicht n Bytes zweier Arrays. (ANSI)
kopiert n Bytes aus Quell-Puffer in Ziel-Puffer. (ANSI)
kopiert einen Block von n Bytes. (ANSI)
setzen von n Bytes des Arrays mit konstantem Wert. (ANSI)
hängt einen String an einen anderen. (ANSI)
sucht ein Zeichen im String. (ANSI)
vergleicht zwei Strings miteinander. (ANSI)
kopiert einen String in einen anderen. (ANSI)
liefert die Länge des Teilstrings von s1, der
keines der Zeichen von String s2 enthält. (ANSI)
liefert einen Zeiger auf einen String mit Fehlermeldungen.
(ANSI)
ermittelt die Länge eines Strings. (ANSI)
hängt einen String bestimmter Länge an einen anderen.
(ANSI)
vergleicht eine bestimmte Länge von zwei Strings
miteinander. (ANSI)
kopiert einen String bestimmter Länge in einen anderen. (ANSI)
sucht in einem String nach dem Vorkommen bestimmter
Zeichen. (ANSI)
sucht in einem String nach dem letzten Vorkommen eines
Zeichen. (ANSI)
sucht im String s1 nach einem Teilstring. (ANSI)
Sucht einen String nach einer von mechreren Zeichenfolgen ab,
die in einem zweiten String definiert sind. (ANSI)
3.1. BIBLIOTHEKSROUTINEN - ÜBERSICHT
3.1.8
Mathematische Routinen
Funktion
-
Beschreibung
abs
acos
asin
atan
atan2
atof
-
atoi
-
atol
-
ceil
-
cos
cosh
div
-
ecvt
exp
fabs
floor
-
fmod
itoa
labs
ldexp
ldiv
log
log10
modf
-
pow
rand
sin
sinh
sqrt
srand
strtod
strtol
strtoul
tan
-
berechnet den Absolutwert eines int-Wertes. (ANSI)
berechnet den Arcus Cosinus des Argumentes c. (ANSI)
berechnet den Arcus Sinus des Argumentes x. (ANSI)
berechnet den Arcus Tangens des Argumentes x. (ANSI)
berechnet den Arcus Tangens des Argumentes y/x. (ANSI)
Ascii TO Float- wandelt eine Zeichenkette in eine
Gleitpunktzahl um. (ANSI)
Ascii TO Integer - wandelt eine Zeichenkette in eine
Integerzahl um. (ANSI)
Ascii TO long - wandelt eine Zeichenkette in einen
long-Wert. (ANSI)
berechnet die kleinste ganze Zahl, die größer oder
gleich dem Wert von x ist. (ANSI)
berechnet den Cosinus des Argumentes x. (ANSI)
berechnet den Cosinus Hyperbolicus des Argumentes x. (ANSI)
dividiert zwei Integerwerte und liefert den Quotienten
sowie den Rest über eine Struktur zurück. (ANSI)
wandelt eine Gleitpunktzahl in eine Zeichenkette um. (ANSI)
berechnet ex . (ANSI)
berechnet den Absolutwert einer Gleitpunktzahl. (ANSI)
berechnet die größte ganze Zahl, die kleiner oder
gleich x ist. (ANSI)
berechnet x modulo y. (ANSI)
konvertiert einen Integer-Wert in einen String. (ANSI)
berechnet den Absolutwert eines long- Wertes. (ANSI)
berechnet x ∗ 2exp . (ANSI)
führt eine long-Division durch. (ANSI)
berechnet den natürlichen Logarithmus. (ANSI)
berechnet den natürlichen Logarithmus Basis 10. (ANSI)
zerlegt x in einem gebrochenen und einen ganzzahligen
Anteil. (ANSI)
berechnet die Potenz xy . (ANSI)
liefert eine Zufallszahl. (ANSI)
berechnet den Sinus des Argumentes x. (ANSI)
berechnet den Sinus Hyperbolicus des Argumentes x. (ANSI)
berechnet die Quadratwurzel des Argumentes x. (ANSI)
initialisiert Zufallsgenerator. (ANSI)
konvertiert einen String in einen double-Wert. (ANSI)
konvertiert einen String in einen long-Wert. (ANSI)
konvertiert einen String in einen unsigned long-Wert. (ANSI)
berechnet den Tangens des Argumentes x. (ANSI)
23
24
3.1.9
KAPITEL 3. BIBLIOTHEKSROUTINEN
Dynamische Verwaltung des Speichers
Routinen zur dynamischen Verwaltung des Speichers.
Funktion
-
Beschreibung
free
calloc
malloc
realloc
-
gibt einen dynamisch belegten Speicherbereich frei. (ANSI)
reserviert Speicherplatz für n-Elemente. (ANSI)
reserviert Speicherplatz. (ANSI)
ändert die Größe des dynamischen Speicherblocks. (ANSI)
3.1.10
Diverses
Hilfreiche Routinen.
Funktion
-
Beschreibung
longjmp
setjmp
-
führt ein nicht lokales goto aus. (ANSI)
bereitet ein nicht lokales goto vor. (ANSI)
3.1.11
Prozeßroutinen
Routinen zur Prozeßverarbeitung.
Funktion
-
Beschreibung
abort
exit
raise
signal
-
bricht einen Prozeß ab. (ANSI)
beendet das laufende Programm. (ANSI)
sendet Softwaresignale. (ANSI)
Signalverarbeitung. (ANSI)
3.1. BIBLIOTHEKSROUTINEN - ÜBERSICHT
3.1.12
Standardroutinen
Allgemeine Standardroutinen.
Funktion
-
Beschreibung
abort
abs
atexit
-
atof
-
atoi
-
atol
-
bsearch
calloc
ecvt
exit
free
itoa
labs
lfind
malloc
qsort
-
rand
realloc
srand
strtod
strtol
strtoul
system
-
bricht einen Prozeß ab. (ANSI)
berechnet den Absolutwert eines int-Wertes. (ANSI)
legt Routinen fest, die am Ende eines Programmms
ausgeführt werden sollen. (ANSI)
Ascii TO Float- wandelt eine Zeichenkette in eine
Gleitpunktzahl um. (ANSI)
Ascii TO Integer - wandelt eine Zeichenkette in eine
Integer um. (ANSI)
Ascii TO long - wandelt eine Zeichenkette in einen
long-Wert. (ANSI)
Binäres Suchen in einer Liste. (ANSI)
reserviert Platz im Hauptspeicher. (ANSI)
wandelt eine Gleitpunktzahl in eine Zeichenkette um. (ANSI)
beendet das laufende Programm. (ANSI)
gibt einen dynamisch belegten Speicherbereich frei. (ANSI)
konvertiert einen Integer-Wert in einen String. (ANSI)
berechnet den Absolutwert eines long- Wertes. (ANSI)
lineare Suche im Array. (ANSI)
reserviert Speicherplatz. (ANSI)
sortiert n-Elemente in auf- und absteigender
Reihenfolge. (ANSI)
liefert eine Zufallszahl. (ANSI)
ändert die Größe des dynamischen Speicherblocks. (ANSI)
initialisiert Zufallsgenerator. (ANSI)
konvertiert einen String in einen double-Wert.
konvertiert einen String in einen long-Wert.
konvertiert einen String in einen unsigned long-Wert.
Ausführung eines DOS-Befehls. (ANSI)
25
26
3.1.13
KAPITEL 3. BIBLIOTHEKSROUTINEN
Datum und Uhrzeit
Routinen zum Setzen, Lesen, Konvertieren von Datum / Uhrzeit des Systems.
Funktion
-
Beschreibung
asctime
ctime
difftime
-
getdate
gettime
gmtime
-
mktime
time
-
konvertiert Datum und Uhrzeit in einen String. (ANSI)
konvertiert Datum und Uhrzeit in einen String. (ANSI)
berechnet den Unterschied zwischen zwei Zeitangaben
in Sekunden. (ANSI)
ermittelt das aktuelle Datum. (ANSI)
ermittelt die Uhrzeit des Systems. (ANSI)
rechnet Datum und Uhrzeit in die Greenwich Mean Time
(GMT) um. (ANSI)
konvertiert die Uhrzeit in das Kalenderformat. (ANSI)
liefert Datum und Uhrzeit des Systems. (ANSI)
3.1.14
Variable Argumente
Routinen zur variablen Parameterliste.
Funktion
-
Beschreibung
va arg
va end
va start
-
Makro für Funktionen mit variabler Parameterzahl. (ANSI)
Makro für Funktionen mit variabler Parameterzahl. (ANSI)
Makro für Funktionen mit variabler Parameterzahl. (ANSI)
Kapitel 4
Funktionen
28
KAPITEL 4. FUNKTIONEN
4.1
abort()
Name
:
abort — bricht einen Prozeß ab.
Benutzung
:
void abort(void);
Prototyp in
:
<stdlib.h> , <process.h>
Beschreibung :
abort() gibt die Meldung:
(ANSI)
• Abnormal program termination
an stderr ab und bricht den laufenden Prozeß ab. An den aufrufenden Prozeß wird der Exit-Code 3 übergeben. Die Funktion exit() bewirkt im Unterschied zu abort() eine normale Programmbeendigung.
Return-Wert: :
keiner
Querverweis :
assert exit raise spawn
atexit exit signal
UNIX
Solaris 2.x : wie oben
SunOS 4.1.x : int abort(void)
:
Beispiel zur Funktion abort()
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
printf("’abort() wird aufgerufen\n"’);
abort();
return 0; /* wird niemals erreicht */
}
4.2. ABS()
4.2
29
abs()
Name
:
abs — berechnet den Absolutwert eines int-Wertes.
#include
Benutzung
:
:
<stdlib.h> oder <math.h>
int abs(int x);
Prototyp in
:
<stdlib.h> oder <math.h>
(ANSI)
Beschreibung :
abs() absolute value berechnet den Absolutwert eines intWertes. Für die Berechnung des Absolutwertes einer Zahl vom
Typ long oder double kann die Funktion labs() bzw. fabs() verwendet werden.
Return-Wert: :
Der Absolutwert von x, d.h.
• x, f alls x ≥ 0,
• −x, f alls x < 0
Querverweis :
Beispiel
:
int x = -2;
printf(“%d\n“’,abs(x));
Ergebnis
:
2
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion abs()
#include <stdio.h>
#include <math.h>
int main(void)
{
int zahl = -1234;
printf("Der absolute Betrag von %d ist %d\n",zahl, abs(zahl));
return 0;
}
30
4.3
KAPITEL 4. FUNKTIONEN
acos()
Name
:
acos — berechnet den Arcus Cosinus des Argumentes x. (ANSI)
Benutzung
:
double acos(double x);
complex acos(complex x);
Prototyp in
:
<math.h> (reel)
<complex.h> (complex)
Beschreibung :
acos() arcosine berechnet den Arcus Cosinus des Argumentes x.
Der Wert von x muß zwischen -1 und +1 (einschließlich) liegen.
Die Funktion ist die Umkehrfunktion von cos().
Return-Wert: :
Die Funktion gibt den Arcus Cosinus von x im Bogenmaß zurück.
Der Wert liegt im Bereich von 0 und pi = 3.1415927.....
Im Fehlerfall, wenn x > 1 oder x < −1 ist, wird der Wert 0
zurückgegeben. Es wird eine Fehlermeldung auf stderr ausgegeben, und die Fehler- variable errno erhält den Wert EDOM (=
domain error).
Fehlerbehandlung kann ev. unter Verwendung der Funktion matherr geändert werden.
Querverweis :
asin atan2 cos sin
atan complex matherr tan
Beispiel
:
printf(“acos(-1.0) = %6.4f\n“,acos(-1.0));
printf(“acos(0.0) = %6.4f\n“,acos(0.0));
printf(“acos(1.0) = %6.4f\n“,acos(1.0));
Ergebnis
:
acos(-1.0) = 3.1416
acos(0.0) = 1.5708
acos(1.0) = 0.0000
UNIX
:
Solaris 2.x : Headerdatei <complex.h> nicht vorhanden; sonst wie oben
SunOS 4.1.x : Headerdatei <complex.h> nicht vorhanden; sonst wie oben
4.3. ACOS()
Beispiel zur Funktion acos()
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 0.5;
result = acos(x);
printf("Der Arcuscosinus von %lf ist %lf\n",x,result);
return 0;
}
31
32
4.4
KAPITEL 4. FUNKTIONEN
asctime()
Name
:
asctime — konvertiert Datum und Uhrzeit in einen String.
(ANSI)
Benutzung
:
char *asctime(struct tm *systime);
Prototyp in
:
<time.h>
Beschreibung :
asctime() (ASCII time) konvertiert Datum und Uhrzeit in einen
String. Datum und Zeit sind in der durch systime adressierten
Struktur vom Typ tm abgelegt.
Diese Struktur wurde zuvor durch einen Aufruf der Funktion localtime() oder gmtime() angelegt und mit Werten gefüllt.
Der in time.h definierte Strukturtyp tm wird bei der Funktion
mktime() beschrieben.
Return-Wert: :
Die Funktion liefert einen Zeiger auf einen String mit Datum und
Uhrzeit zurück. Der String ist 26 Bytes lang. Das genaue Format
ist bei der Funktion ctime() beschrieben.
Querverweis :
ctime gmtime stime time
difftime localtime strftime tzset
Beispiel
struct tm systime;
time t sec;
:
time(&sec);
systime = localtime(&sec);
printf(“Datum und Uhrzeit: %s\n“,asctime(systime));
Ergebnis
:
Datum und Uhrzeit : Thu Oct 15 08:32:16 1991
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.4. ASCTIME()
33
Beispiel zur Funktion asctime()
#include <stdio.h>
#include <string.h>
#include <time.h>
int main(void)
{
struct tm t;
char str[80];
/* Beispiel fuer die Initialisierung
einer tm-Struktur */
t.tm_sec
t.tm_min
t.tm_hour
t.tm_mday
t.tm_mon
t.tm_year
=
=
=
=
=
=
1;
30;
9;
22;
11;
56;
t.tm_wday
t.tm_yday
= 4;
= 0;
t.tm_isdst
= 0;
/*
/*
/*
/*
/*
/*
Sekunden */
Minuten */
Stunde */
Tag des Monats */
Monat */
Jahr ohne Jahrhundert */
/* Tag der Woche */
/* wird von asctime
nicht angezeigt */
/* "Daylight SavTime" Sommerzeit; wird von
asctime nicht angezeigt
*/
/* konvertiert die Struktur in einen
nullterminierten String */
strcpy(str, asctime(&t));
printf("%s\n", str);
return 0;
}
34
4.5
KAPITEL 4. FUNKTIONEN
asin()
Name
:
asin — berechnet den Arcus Sinus des Argumentes x.
Benutzung
:
double asin(double x);
complex asin(complex x);
Prototyp in
:
<math.h> (reel)
<complex.h> (complex)
(ANSI)
Beschreibung :
asin() (arcsine) berechnet den Arcus Sinus des Argumentes x. Der
Wert von x muß zwischen -1 und +1 (einschließlich) liegen. Die
Funktion ist die Umkehrfunktion von sin().
Return-Wert: :
Die Funktion gibt den Arcus Sinus von x im Bogenmaß zurück.
Der Wert liegt im Bereich von -pi/2 und pi/2 (pi = 3.1415927....).
Im Fehlerfall, wenn x > 1 oder x < −1 ist, wird der Wert 0
zurückgegeben. Es wird eine Fehlermeldung auf stderr ausgegeben, und die Fehler- variable errno erhält den Wert EDOM (=
domain error).
Fehlerbehandlung kann ev. unter Verwendung der Funktion matherr geändert werden.
Querverweis :
acos atan2 cos sin
atan complex matherr tan
Beispiel
:
printf(“asin(-1.0) = %6.4f\n“,asin(-1.0));
printf(“asin(0.0) = %6.4f\n“,asin(0.0));
printf(“asin(1.0) = %6.4f\n“,asin(1.0));
Ergebnis
:
asin(-1.0) = -1.5708
asin(0.0) = 0.0000
asin(1.0) = 1.5708
UNIX
:
Solaris 2.x : Headerdatei <complex.h> nicht vorhanden; sonst wie oben
SunOS 4.1.x : Headerdatei <complex.h> nicht vorhanden; sonst wie oben
4.5. ASIN()
Beispiel zur Funktion asin()
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 0.5;
result = asin(x);
printf("Der Arcussinus von %lf ist %lf\n",
x, result);
return(0);
}
35
36
4.6
KAPITEL 4. FUNKTIONEN
assert()
Name
:
assert — überprüft den Ausdruck expression.
Benutzung
:
void assert(int expression);
Prototyp in
:
<assert.h>
Beschreibung :
(ANSI)
Das Makro assert() (assertion) überprüft den Ausdruck expression. Ist das Ergebnis 0 (= falsch), wird die Meldung
• Assertion failed: expression, file: name , line: number
ausgegeben. Danach erfolgt ein Abbruch des Programms. Es ist
name der Name des Programms und line die Zeilennummer, in
der assert() aufgerufen wurde. Ist der Ausdruck expression ein
von 0 verschiedener Wert (= wahr), erfolgt keine Aktion.
Das Makro kann zum Auffinden von logischen Fehlern in einem
Programm eingesetzt werden.
Nach dem Entfernen aller Fehler aus dem Programm, kann die
Konstante NDEBUG mit einem beliebigen Wert belegt werden,
damit der Präprozessor alle Aufrufe von assert() aus dem Quellcode entfernt.
Return-Wert: :
keiner
Querverweis :
abort
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 */
Ergebnis
:
Ausgabe in diesem Beispiel:
Assertion faild: y > 0, file: C: assert.c, line: 10
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.6. ASSERT()
Beispiel zur Funktion assert()
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
struct ITEM {
int key;
int value;
};
/* Eintrag in Liste, damit Liste nicht
leer ist */
void additem(struct ITEM *itemptr)
{
assert(itemptr != NULL);
/* Eintrag in Liste einfuegen */
}
int main(void)
{
additem(NULL);
return 0;
}
37
38
4.7
KAPITEL 4. FUNKTIONEN
atan()
Name
:
atan — berechnet den Arcus Tangens des Argumentes x. (ANSI)
Benutzung
:
double atan(double x);
complex atan(complex x);
Prototyp in
:
<math.h> (reel)
<complex.h> (complex)
Beschreibung :
atan() (arc tangent) berechnet den Arcus Tangens des Argumentes x. Die Funktion ist die Umkehrfunktion der Funktion tan().
Return-Wert: :
Die Funktion gibt den Arcus Tangens von x im Bogenmaß
zurück. Der Wert liegt im Bereich von -pi/2 und pi/2 (pi =
3.1415927....).
Querverweis :
acos atan2 cos sin
asin tanh cosh sinh atan complex matherr tan
Beispiel
:
printf(“atan(-1.0) = %7.4f\n“,atan(-1.0));
printf(“atan(0.0) = %7.4f\n“,atan(0.0));
printf(“atan(1.0) = %7.4f\n“,atan(1.0));
Ergebnis
:
atan(-1.0) = -0.7854
atan(0.0) = 0.0000
atan(1.0) = 0.7854
Hinweis: 0.7854 0 = pi/4.
UNIX
:
Solaris 2.x : Headerdatei <complex.h> nicht vorhanden; sonst wie oben
SunOS 4.1.x : Headerdatei <complex.h> nicht vorhanden; sonst wie oben
4.7. ATAN()
Beispiel zur Funktion atan()
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 0.5;
result = atan(x);
printf("Der Arcustangens von %lf ist %lf\n",x,result);
return(0);
}
39
40
4.8
KAPITEL 4. FUNKTIONEN
atan2()
Name
:
atan2 — berechnet den Arcus Tangens von y/x.
Benutzung
:
double atan2(double y, double x);
Prototyp in
:
<math.h> (reel)
(ANSI)
Beschreibung :
atan2() (arc tangent 2) berechnet den Arcus Tangens des Argumentes x.
Return-Wert: :
Die Funktion gibt den Arcus Tangens von x im Bogenmaß
zurück. Der Wert liegt im Bereich von -pi/2 und pi/2 (pi =
3.1415927....).
Der Quadrant für den Return-Wert wird durch die Vorzeichen
beider festgelegt.
Sind beide Argumente 0, so erhält die Fehlervariable errno den
Wert EDOM (domain error) und eine entsprechende Fehlermeldung wird auf stderr ausgegeben. Der Return-Wert ist in diesem
Fall 0.
Querverweis :
acos atan cos sin
asin matherr
Beispiel
:
double x = 3; y = 3; /* y/x =1 */
printf(“atan2(y,x) = %10f\n“,atan2(y,x));
printf(“atan2(-y,x) = %10f\n“,atan2(-y,x));
printf(“atan2(y,-x) = %10f\n“,atan2(y,-x));
printf(“atan2(-y,x) = %10f\n“,atan2(-y,x));
Ergebnis
:
atan2(y,x) = 0.785398
atan2(-y,x) = -0.785398
atan2(y,-x) = 2.356194
atan2(-y,x) = -2.356194
Hinweis: 0.785398 = pi/4.
UNIX
:
2.356194 = 3/4*pi
Solaris 2.x : Headerdatei <complex.h> nicht vorhanden; sonst wie oben
SunOS 4.1.x : Headerdatei <complex.h> nicht vorhanden; sonst wie oben
4.8. ATAN2()
Beispiel zur Funktion atan2()
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 90.0, y = 45.0;
result = atan2(y, x);
printf("Der Arcustangens von %lf "
"ist %lf\n", (y / x), result);
return 0;
}
41
42
4.9
KAPITEL 4. FUNKTIONEN
atexit()
Name
:
atexit — legt Routinen fest, die am Ende eines Programms ausgeführt werden sollen.
(ANSI)
Benutzung
:
int atexit(void(*func)(void));
Prototyp in
:
<stdlib.h> (reel)
Beschreibung :
der Funktion atexit() (at exit) wird ein Zeiger func auf eine Funktion vom Typ void übergeben, die am Ende des Programms aufgerufen werden sollen.
Jeder Aufruf von atexit() registriert einen Zeiger auf eine Funktion, die nach dem last in, first out- Prinzip verwaltet wird. Die
Funktion des letzen Aufrufs von atexit() wird als erstes bearbeitet
(max. 32 Aufrufe).
Return-Wert: :
Die Funktion gibt im Fehlerfall einen Wert ungleich 0, sonst den
Wert 0 aus.
Querverweis :
acos atan cos sin
asin matherr
UNIX
Solaris 2.x : wie oben
SunOS 4.1.x : steht nicht zur Verfügung
:
Beispiel(1) zur Funktion atexit()
#include <stdio.h>
#include <stdlib.h>
void exit_fn1(void)
{
printf("Exit-Funktion #1 aufgerufen\n");
}
void exit_fn2(void)
{
printf("Exit-Funktion #2 aufgerufen\n");
}
int main(void)
{
/* Exit-Funktion #1 eintragen */
4.9. ATEXIT()
43
atexit(exit_fn1);
/* Exit-Funktion #2 eintragen */
atexit(exit_fn2);
return 0;
/* Exit-Funktionen werden
nach return aufgerufen */
}
Beispiel(2) zur Funktion atexit()
#include <stdlib.h>
int atexit(void(*func)(void));
void main(void)
{
void func1(void), func2(void);
atexit(func1);
atexit(func2);
printf("\n Ende des Programms\n");
}
void func1(void)
{
printf("Funktion func1() wurde ausgefuehrt. \n");
}
void func2(void)
{
printf("Funktion func2() wurde ausgefuehrt. \n");
}
/* Ergebnis :
*/
Ende des Programms.
Funktion func2() wurde ausgefuehrt
Funktion func1() wurde ausgefuehrt
44
4.10
KAPITEL 4. FUNKTIONEN
atof()
Name
:
atof — Ascii TO Float - wandelt eine Zeichenkette in eine Gleitpunktzahl um.
(ANSI)
Benutzung
:
double atof (const char *str);
Prototyp in
:
<stdlib.h> , <math.h>
Beschreibung :
atof wandelt eine Zahl, die als ASCII- Zeichenkette gespeichert
ist, in einen double-Wert um und meldet diesen als Funktionswert zurück. Führende Zwischenraumzeichen (Leer-, Tabulator-,
Newline-Zeichen) von str werden überlesen. Führende Vorzeichen werden verarbeitet. Die Umwandlung wird beim ersten
N icht − Zif f er − Zeichen beendet (Ausnahme: das Zeichen .).
Die Funktion strod() bewirkt dieselbe Umwandlung und liefert
außerdem einen Zeiger auf das Zeichen, bei dem die Umwandlung abgebrochen wurde. Zur Umwandlung in eine Zahl vom
Typ int oder long kann die Funktion atoi() bzw. atol() verwendet
werden.
Return-Wert: :
Die Funktion gibt einen double-Wert der korrespondierenden
Zeichenkette zurück. Funktionswert ist 0, wenn Konvertierung
nicht fehlerfrei ausgeführt werden konnte. Falls ein Überlauf erzeugt wurde, ist der Return-Wert undefiniert.
Querverweis :
atoi ecvt gcvt strod
atol fcvt scanf
Beispiel
:
char str[10] = “ 12.67h78“;
printf(“%f\n“,atof(str));
Ergebnis
:
12.670000
UNIX
:
Solaris 2.x : wie oben (Exponentialschreibweise erlaubt)
SunOS 4.1.x : wie oben (Exponentialschreibweise erlaubt)
• In manchen UNIX-Versionen ist die Angabe von Exponenten (gekennzeichnet mit e oder E) erlaubt.
• Diese Funktion ist in LATTICE-C unter MS-DOS nicht
verfügbar.
4.10. ATOF()
Beispiel zur Funktion atof()
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
float f;
char *str = "12345.67"’;
f = atof(str);
printf("String = %s \nfloat = %f\n",
str, f);
return 0;
}
45
46
4.11
KAPITEL 4. FUNKTIONEN
atoi()
Name
:
atoi — ASCII to Integer - wandelt eine Zeichenkette in eine Integer um.
(ANSI)
Benutzung
:
int atoi (const char *str);
Prototyp in
:
<stdlib.h>
Beschreibung :
atoi() (alphanumeric to int) wandelt eine Zahl, die als ASCII- Zeichenkette gespeichert ist, in einen int-Wert um und meldet diesen als Funktionswert zurück. Führende Zwischenraumzeichen
(Leer-, Tabulator-, Newline-Zeichen) von str werden überlesen.
Ein Dezimalpunkt oder Exponent wird nicht als Teil einer Zahl
angesehen.
Führende Vorzeichen werden verarbeitet. Die Umwandlung
wird beim ersten N icht − Zif f er − Zeichen beendet. Zur Umwandlung in eine Zahl vom Typ int oder long kann die Funktion
atoi() bzw. atol() verwendet werden.
Return-Wert :
Die Funktion gibt einen int-Wert der korrespondierenden Zeichenkette zurück. Funktionswert ist 0, wenn Konvertierung nicht
fehlerfrei ausgeführt werden konnte. Falls die zu wandelnde
Zahl zu groß für den Typ int wird, ist der Return-Wert undefiniert.
Querverweis :
atof ecvt gcvt strod
atol fcvt scanf
Beispiel
:
char *str = “ +125 Wert“;
printf(“atoi(str) = %d\n“,atoi(str));
Ergebnis
:
atoi(str) = 125
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.11. ATOI()
Beispiel zur Funktion atoi()
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
int n;
char *str = "12345.678";
n = atoi(str);
printf("String = %s \nInteger = %d\n",
str, n);
return 0;
}
47
48
4.12
KAPITEL 4. FUNKTIONEN
atol()
Name
:
atol — ASCII TO long - wandelt eine Zeichenkette in einen longWert.
(ANSI)
Benutzung
:
long atol (const char *str);
Prototyp in
:
<stdlib.h>
Beschreibung :
atol() (alphanumeric to long) wandelt eine Ganzzahl, die als
ASCII- Zeichenkette gespeichert ist, in einem long-Wert um und
meldet diesen als Funktionswert zurück. Führende Zwischenraumzeichen (Leer-, Tabulator-, Newline-Zeichen) von str werden überlesen.
Ein Dezimalpunkt oder Exponent wird nicht als Teil einer Zahl
angesehen.
Führende Vorzeichen werden verarbeitet. Die Umwandlung
wird beim ersten N icht − Zif f er − Zeichen beendet. Die Funktion strol() bewirkt dieselbe Umwandlung und liefert außerdem
einen Zeiger auf das Zeichen, bei dem die Umwandlung abgebrochen wurde. Zur Umwandlung in eine Zahl vom Typ int oder
double kann die Funktion atoi() bzw. atof() verwendet werden.
Return-Wert :
Die Funktion gibt einen long-Wert der korrespondierenden Zeichenkette zurück. Funktionswert ist 0, wenn Konvertierung nicht
fehlerfrei ausgeführt werden konnte.
Querverweis :
atof fcvt strtod
atoi gcvt strtol
ecvt scanf strtoul
Beispiel
:
char *str = “ -12345678.- Wert“;
printf(“atol(str) = %ld\n“,atol(str));
Ergebnis
:
atol(str) = -12345678
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.12. ATOL()
Beispiel zur Funktion atol()
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
long l;
char *str = "98765432";
l = atol(str);
printf("String
= %s \n"
"Long-Integer = %ld\n",
str, l);
return(0);
}
49
50
4.13
KAPITEL 4. FUNKTIONEN
bsearch()
Name
:
bsearch — Binäres Suchen in einer Liste.
(ANSI)
Benutzung
:
void ∗bsearch(const void ∗key, const void ∗array, size t n, size t
size, int(∗compare)());
Prototyp in
:
<stdlib.h>
Beschreibung :
bsearch() (binary search) sucht in einem sortierten Vektor einen
durch key spezifizierten Wert. Der Vektor enthält n- Vektorelemente der Größe size. Der Datentyp size t ist in stdlib.h als unsigned int definiert.
Das Argument compare ist ein Zeiger auf eine Funktion, die den
gesuchten Wert mit dem Vektorelement vergleicht. Die Definition einer solchen Funktion wird bei der Funktion qsort() beschrieben.
Return-Wert :
Die Funktion gibt die Adresse des ersten Vektorelementes
zurück, das mit dem gesuchten Wert (key) übereinstimmt. Ist ein
solches Vektorelement nicht vorhanden, wird ein NULL- Zeiger
zurückgeliefert.
besearch() interpretiert den Rückgabewert der benutzerdefinierten Vergleichsfunktion ∗compare() wie folgt:
Wert
<0
== 0
>0
Bedeutung
∗elem1 < ∗elem2
∗elem1 == ∗elem2
∗elem1 > ∗elem2
Querverweis :
lfind lsearch qsort
Beispiel
int scmp(char **s1, char **s2);
static char *farben[]={“rot“,“blau“,“gelb“};
static char key[]= “pink“;
:
if (bsearch(key,farben,5,sizeof( char *),scmp) == NULL)
printf(“Farbe %s nicht gefunden\n“,key);
....
int scmp (char **s1, char **s2)
{ return strcmp(*s1, *s2); }
4.13. BSEARCH()
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion bsearch()
#include
#include
<stdlib.h>
<stdio.h>
#define NELEMS(arr) (sizeof(arr) / sizeof(arr[0]))
typedef int (*fcmp)(const void *, const void *);
int
int
int
numeric (int *, int *);
lookup(int);
numarray[]
=
{123, 145, 512,};
int main(void)
{
if (lookup(512))
printf("512 ist in der Tabelle enthalten.\n");
else
printf("512 befindet sich nicht in der Tabelle.\n");
return 0;
}
int numeric (int *p1, int *p2)
{
return(*p1 - *p2);
}
int lookup(int key)
{
int *itemptr;
itemptr = (int *) bsearch (&key, numarray, NELEMS(numarray),
sizeof(int), (fcmp) numeric);
return (itemptr != NULL);
}
51
52
4.14
KAPITEL 4. FUNKTIONEN
calloc()
Name
:
calloc — reserviert Platz im Hauptspeicher.
Benutzung
:
void *calloc (size t n, size t size);
Prototyp in
:
<stdlib.h>
(ANSI)
Beschreibung :
calloc() (core allocation) reserviert Platz im Hauptspeicher für
einen Block von n*size-Bytes und initialisiert diesen im Gegensatz zur Funktion malloc() mit 0.
Return-Wert: :
Die Funktion gibt einen Zeiger auf die Anfangsadresse des zugeteilten Speicherbereiches zurück. Wenn nicht genügend Speicherplatz vorhanden ist oder n oder size den Wert 0 hat, liefert
die Funktion den NULL-Zeiger.
Querverweis :
farcalloc free malloc realloc
Beispiel
size t n;
int *p;
:
printf(“Wieviel Ganzzahlen wollen Sie eingeben \n“);
scanf(“%u “,&n);
p = (int *) calloc(n, sizeof(int));
if (p == NULL)
printf(“Nicht genügend Speicherplatz vorhanden \n“);
else
Eingabe der Zahlen in den reservierten Bereich
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.14. CALLOC()
Beispiel zur Funktion calloc()
#include <stdio.h>
#include <alloc.h>
int main(void)
{
char *str = NULL;
/* Speicher fuer den String reservieren */
str = calloc(10, sizeof(char));
/* "Hallo" in den String kopieren */
strcpy(str, "Hallo");
/* String anzeigen */
printf("Das ist der String: %s\n", str);
/* Den vom String belegten
Speicher freigeben */
free(str);
return 0;
}
53
54
4.15
KAPITEL 4. FUNKTIONEN
ceil()
Name
:
ceil — berechnet die kleinste ganze Zahl, die größer oder gleich
x ist.
(ANSI)
Benutzung
:
double ceil(double x);
Prototyp in
:
<math.h>
Beschreibung :
ceil() (ceiling=Decke) berechnet die kleinste ganze Zahl, die
größer oder gleich x ist.
Die Gegenfunktion zur Funktion ceil() ist die Funktion floor().
Return-Wert: :
Die Funktion liefert ein double-Wert als Ergebnis zurück.
Querverweis :
floor fmod
Beispiel
:
double x1 = 2.3;
double x2 = -2.7;
printf(“ceil(%4.1f) = %4.1f\n“,x1,ceil(x1));
printf(“ceil(%4.1f) = %4.1f\n“,x2,ceil(x2));
Ergebnis
:
ceil(2.3) = 3.0
ceil(-2.7) = -2.0
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion ceil()
#include <math.h>
#include <stdio.h>
int main(void)
{
double zahl = 123.54;
double unten, oben;
unten = floor(zahl);
oben = ceil(zahl);
printf("urspruengliche Zahl: %5.2lf\n", zahl);
printf("abgerundet:
%5.2lf\n", unten);
printf("aufgerundet:
%5.2lf\n", oben);
return 0;
4.15. CEIL()
}
55
56
4.16
KAPITEL 4. FUNKTIONEN
chdir()
Name
:
chdir — wechselt das aktuell gesetze Directory.
Benutzung
:
int chdir(const char *path);
Prototyp in
:
<dir.h>
Beschreibung :
chdir() (change directory) wechselt in das durch path
spezifizierte Verzeichnis.
Die Pfadangabe path kann die Laufwerksbezeichnung mit enthalten (DOS).
Return-Wert: :
Die Funktion liefert bei fehlerfreier Ausführung den Wert 0, sonst
-1. Zusätzlich wird die Variable errno gesetzt.
Querverweis :
getcurdir mkdir system
getcwd rmdir
Beispiel
:
if (chdir (“a:\test“) != 0) {
puts(“Verzeichnis- oder Laufwerksname falsch“);
} /* end if */
Ergebnis
UNIX
:
:
Solaris 2.x : Mit Headerdatei <unistd.h>, sonst wie oben
SunOS 4.1.x : Mit Headerdatei <unistd.h>, sonst wie oben
4.16. CHDIR()
Beispiel zur Funktion chdir()
/* Beispiel fuer TURBO C ! */
#include <stdio.h>
#include <stdlib.h>
#include <dir.h>
char alt_dir[MAXDIR];
char neu_dir[MAXDIR];
/* Wechselt das momentan gesetzte Directory */
int main(void)
{
if (getcurdir(0, alt_dir))
{
perror("getcurdir()");
exit(1);
}
printf("Aktuelles Directory ist: \\%s\n", alt_dir);
if (chdir("\\"))
{
perror("chdir()");
exit(1);
}
if (getcurdir(0, neu_dir))
{
perror("getcurdir()");
exit(1);
}
printf("Aktuelles Directory ist jetzt: "
"\\%s\n", neu_dir);
printf("\nIn das urspruengliche Directory "
"zurueckwechseln: \\%s\n", alt_dir);
if (chdir(alt_dir))
{
perror("chdir()");
exit(1);
}
return 0;
}
57
58
4.17
KAPITEL 4. FUNKTIONEN
chmod()
Name
:
chmod — ändert die Zugriffsrechte einer Datei.
Benutzung
:
int chmod(char *name, int permission);
Prototyp in
:
<sys\stat.h> /* Def. der symbol. Konstanten */
<io.h> /* Prototyp der Funktion */
Beschreibung :
chmod() (change mode) ändert die Zugriffsrechte der Datei name durch die mit permission gesetzten Rechte. Als permission
kann eine vierstellige Oktalzahl angegeben werden, wobei die
einzelnen Bits die unter UNIX üblichen Bedeutung haben.
Für permission sollten die in sys\stat.h definierten symbolischen
Konstanten benutzt werden. Unter DOS werden nur die folgenden Werte verwendet: permission Bedeutung S IWRITE nur
Schreiben S IREAD nur Lesen S IREAD — S IWRITE Lesen und
Schreiben.
Jeder andere Wert wird ignoriert. Da unter DOS jede Datei lesbar
ist, sind S IREAD — S IWRITE und S IWRITE gleichbedeutend.
Return-Wert: :
Die Funktion liefert die Zahl 0 zurück, wenn die Zugriffsrechte erfolgreich geändert wurden. Im Fehlerfall ist -1 der ReturnWert und die Fehlervariable errno erhält den Wert ENOENT (=
no such file or directory).
Querverweis :
chmod
Beispiel
:
if (chmod(“test.dat“,S IREAD) == -1)
fprintf(stderr,“Kann Zugriffsrecht nicht aendern \n“);
UNIX
:
Solaris 2.x : Nur <sys/stat.h> muß eingebunden werden
SunOS 4.1.x : Nur <sys/stat.h> muß eingebunden werden
4.17. CHMOD()
Beispiel zur Funktion chmod()
#include <sys\stat.h>
#include <stdio.h>
#include <io.h>
#include <string.h>
#include <fcntl.h>
#include <process.h>
void make_read_only(char *filename);
int main(void)
{
int handle;
char buf[11] = "0123456789";
make_read_only("NOTEXIST.FIL");
/* aendert den voreingestellten Dateimodus von Text auf binaer */
_fmode = O_BINARY;
/* erzeugt eine binaere Datei fuer lesenden
und schreibenden Zugriff */
handle = creat("MYFILE.FIL",
S_IREAD | S_IWRITE);
/* versucht 10 Bytes in die Datei zu schreiben */
if (write(handle, buf, strlen(buf)) == -1)
{
printf("Fehler beim Schreibversuch!\n");
exit(1);
}
/* schliesst die Datei */
close(handle);
make_read_only("MYFILE.FIL");
return 0;
}
void make_read_only(char *filename)
{
int stat;
stat = chmod(filename, S_IREAD);
if (stat)
printf("Konnte %s nicht als read-only "
"markieren!\n", filename);
else
printf("%s als read-only markiert!\n", filename);
}
59
60
KAPITEL 4. FUNKTIONEN
4.18
clearerr()
Name
:
clearerr — setzt die Fehlerflags einer offenen Datei zurück.
(ANSI)
Benutzung
:
void clearerr(FILE ∗fp);
Prototyp in
:
<stdio.h>
Beschreibung :
clearerr() (clear error) löscht das Fehler-Flag und das DateiendeFlag der mit dem File-Pointer fp verbundenen Datei.
Diese Funktion wird üblicherweise im Zusammenhang mit
Fehlerbehandlungs-Routinen für die Datei-E/A benutzt.
Return-Wert: :
Keiner
Querverweis :
eof feof ferror perror
Beispiel
UNIX
s.u.
Solaris 2.x / SunOS 4.1.x : wie oben
:
:
Beispiel zur Funktion clearerr()
#include <stdio.h>
int main(void)
{
FILE *fp;
char ch;
/*
fp
/*
ch
oeffnet eine Datei zum Schreiben */
= fopen("DUMMY.FIL", "w");
loest durch einen Leseversuch eine Fehlerbedingung aus */
= getc(fp);
if ferror(fp)
{
/* zeigt die Fehlermeldung an */
printf("Fehler beim Lesen der Datei DUMMY.FIL\n");
/* setzt die Fehlerbedingung und den EOF-Indikator zurueck */
clearerr(fp);
}
fclose(fp);
return 0;
}
4.19. CLOCK()
4.19
61
clock()
Name
:
clock — bestimmt die Prozessorzeit, die das Programm bisher
verbraucht hat.
(ANSI)
Benutzung
:
clock t clock(void);
Prototyp in
:
<time.h>
Beschreibung :
clock() (clock) bestimmt die Prozessorzeit, die das Programm bisher verbraucht hat.
Der Datentyp clock t ist in time.h als long definiert.
Die Einheit für die Prozessorzeit ist abhängig vom Compiler.
Durch die Division mit der in time.h definierten Konstanten
CLK TCK wird das Ergebnis in Sekunden umgerechnet.
Return-Wert: :
Die Funktion liefert die Prozessorzeit in einer systemabhängigen
Einheit (Ticks) zurück. Wenn die Prozessorzeit nicht bestimmt
oder dargestellt werden kann, ist der Return-Wert -1.
Querverweis :
time
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : long clock()
(allerdings nicht in time.h definiert; kein Include-File notwendig)
Beispiel zur Funktion clock()
#include <time.h>
#include <stdio.h>
int main(void)
{
clock_t end;
printf("Druecken Sie eine beliebige Taste!\n");
getch();
end = clock();
printf("%lf Sekunden sind seit Programmstart "
"verstrichen;\nTaste druecken!\n",
end / CLK_TCK);
getch();
return 0;
}
62
KAPITEL 4. FUNKTIONEN
4.20
close()
Name
:
close — schließt eine Datei.
Benutzung
:
int close(int fd);
Prototyp in
:
<io.h>
Beschreibung :
close() (close) schließt eine mit dem File-Handle fd verbundene
Datei.
Der File-Handle ist der Rückgabewert der Funktionen creat()
oder open.
Return-Wert: :
Die Funktion liefert den Wert 0 als Ergebnis zurück, falls die Datei
geschlossen werden konnte. Im Fehlerfall wird -1 zurückgegeben
und die Fehlervariable errno wird entsprechend gesetzt.
Querverweis :
chsize creatnew open sopen creat dup read write creat fclose
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : Headerfile ist <unistd.h>,
sonst wie oben
Beispiel zur Funktion close()
#include
#include
#include
#include
<string.h>
<fcntl.h>
<io.h>
<sys\stat.h>
int main(void)
{
int handle;
char buf[11] = "0123456789";
/* erzeugt eine Datei mit 10 Bytes */
handle = open("’NEW.FIL"’, O_RDWR | O_CREAT,
S_IREAD | S_IWRITE );
write(handle, buf, strlen(buf));
/* schliesst die Datei */
close(handle);
4.20. CLOSE()
return 0;
}
63
64
4.21
KAPITEL 4. FUNKTIONEN
cos()
Name
:
cos — berechnet den Cosinus des Argumentes x.
Benutzung
:
double cos(double x);
complex cos(complex x);
Prototyp in
:
<math.h> (reel)
<complex.h> (complex)
(ANSI)
Beschreibung :
cos() (cosine) berechnet den Cosinus des Argumentes x.
Der Wert von x wird als Bogenmaß interpretiert. Das Argument
x wird durch Modulodivision in den Bereich 0 bis 2*pi transformiert, wobei pi = 3.1415927... ist. Ist der Absolutwert des Argumentes sehr groß, so kann daraus eine zu große Ungenauigkeit
für das Ergebnis entstehen.
Return-Wert: :
Die Fucosnktion gibt den Cosinus von x im Bogenmaß zurück.
Der Wert liegt im Bereich von -1 und +1.
Im Fehlerfall, wenn der Argumentwert zu groß für ein signifikantes Ergebnis ist, wird der Wert 0 zurückgegeben. Es wird eine
Fehlermeldung auf stderr ausgegeben, und die Fehler- variable
errno erhält den Wert ERANGE (= range error).
Fehlerbehandlung kann ev. unter Verwendung der Funktion matherr geändert werden.
Querverweis :
acos atan2 matherr
asin complex sin
atan cosh tan
Beispiel
:
double pi = 3.1415927;
printf(“cos(0.0) = %6.4f\n“,cos(x));
printf(“cos(pi/2) = %6.4f\n“,cos(y));
printf(“cos(pi) = %6.4f\n“,cos(z));
Ergebnis
:
cos(0.0) = 1.0000
cos(pi/2) = 0.0000
cos(pi) = -1.0000
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.21. COS()
Beispiel zur Funktion cos()
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 0.5;
result = cos(x);
printf("Der Cosinus von %lf ist %lf\n",
x, result);
return 0;
}
65
66
4.22
KAPITEL 4. FUNKTIONEN
cosh()
Name
:
cosh — berechnet den Cosinus Hyperbolicus des Argumentes x.
(ANSI)
Benutzung
:
double cosh(double x);
complex cosh(complex x);
Prototyp in
:
<math.h> (reel)
<complex.h> (complex)
Beschreibung :
cosh() hyperbolic cosine berechnet den Cosinus Hyperbolicus
des Argumentes x.
Return-Wert: :
Die Funktion gibt den Cosinus Hyperbolicus von x im Bogenmaß
zurück. Der Wert ist größer gleich +1.
Ist das Ergebnis zu groß, so wird HUGE VAL zurückgegeben
und die Fehlervariable errno erhält den Wert ERANGE (=range
error).
Querverweis :
acos atan2 matherr tan asin complex sin tanh
atan cos sinh
Beispiel
:
printf(“cosh(-2.0) = %6.4f\n“,cosh(-2.0));
printf(“cosh(0.0) = %6.4f\n“,cosh(0.0));
printf(“cosh(2.0) = %6.4f\n“,cosh(2.0));
Ergebnis
:
UNIX
:
cosh(-2.0) = 3.7622
cosh(0.0) = 1.0000
cosh(2.0) = 3.7622
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion cosh()
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 0.5;
result = cosh(x);
printf("Der Cosinus hyperbolicus von \ %lf ist %lf\n", x, result);
return 0;
}
4.23. CREAT()
4.23
67
creat()
Name
:
creat — erzeugt eine neue oder überschreibt eine bereits vorhandene Datei.
(ANSI)
Benutzung
:
int creat(char *name, int permission);
Prototyp in
:
<sys\stat.h> (Def. symbolischer Konstanten)
<io.h> (Prototyp)
Beschreibung :
creat() (creat) erzeugt eine neue Datei mit dem Dateinamen name
und eröffnet sie zum Schreiben.
Die Zugriffsrechte werden über permission für die spätere Öffnung festgelegt, wobei permission die Bedeutung unter UNIX
hat.
Eine bereits existierende Datei mit Schreibrecht wird auf die
Länge 0 verkürzt. Die vorhandenen Zugriffsrechte verändern
sich dadurch nicht.
Für permission sollten die in sys\stat.h definierten symbolischen
Konstanten benutzt werden. Unter DOS werden nur die unter
chmod() beschriebenen Konstanten verwendet.
creat() soll durch open(),fopen(),...usw. ersetzt werden.
Return-Wert: :
Die Funktion gibt einen File-Handle zurück, wenn die Datei
eröffnet werden kann.
Im Fehlerfall ist der Return-Wert -1 und die Fehlervariable errno
erhält eine der folgen Konstanten:
Konstante
Bedeutung
EACCES
Datei schreibgeschützt
EMFILE
zu viele Dateien eröffnet
ENOENT
ungültiger Dateiname
Querverweis :
chmod close dup2 open
chmod creatnew fmode sopen
chsize creattemp fopen write
close dup
Beispiel
:
UNIX
:
if ((fd = creat(“test.dat“,S IREAD)) == -1)
printf(“Datei %s kann nicht erzeugt werden \n“, “test.dat“);
Solaris 2.x / SunOS 4.1.x : Headerfile ist <sys/stat.h>,
sonst wie oben
68
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion creat()
#include
#include
#include
#include
<sys\stat.h>
<string.h>
<fcntl.h>
<io.h>
int main(void)
{
int handle;
char buf[11] = "0123456789";
/* Aendert den voreingestellten Dateimodus
von Text auf binaer */
_fmode = O_BINARY;
/* erzeugt eine binaere Datei fuer lesenden
und schreibenden Zugriff */
handle = creat("DUMMY.FIL",
S_IREAD | S_IWRITE);
/* schreibt 10 Bytes in die Datei */
write(handle, buf, strlen(buf));
/* schliesst die Datei */
close(handle);
return 0;
}
4.24. CTIME()
4.24
69
ctime()
Name
:
ctime — konvertiert Datum und Uhrzeit in einen String. (ANSI)
Benutzung
:
char *ctime(const time t *zeit);
Prototyp in
:
<include.h>
Beschreibung :
ctime() (convert time) konvertiert Datum und Uhrzeit in einen
String. Hierbei wird der mit zeit angegebene Wert als Anzahl
Sekunden interpretiert, die seit dem 1. Januar 1970 00:00:00 Uhr
(GMT) vergangen sind. Der erzeugte String hat folgendes Format:
Mon May 17 11 : 45 : 56 1988
Tag Monat std Min Sek Jahr
Der Datentype time t ist in time.h definiert. Die Funktion ctime(zeit) ist wirkungsgleich mit asctime(localtime(zeit)).
Die aktuelle Zeit in Sekunden kann mit der Funktion time() bestimmt werden.
Return-Wert: :
Die Funktion liefert die Anfangsadresse des Strings zurück.
Querverweis :
asctime ftime localtime timezone daylight getdate
settime tzset difftime gmtime time
Beispiel
:
time t sec;
time(&sec);
printf(”Datum und Uhrzeit %s \n“,ctime(&sec));
Ergebnis
:
Datum und Uhrzeit: Tue Oct 25 15:00:51 1988
UNIX
:
Solaris 2.x / SunOS 4.1.x : Headerdatei ist <time.h>,
sonst wie oben
Beispiel zur Funktion ctime()
#include <stdio.h>
#include <time.h>
int main(void)
{
time_t t;
time(&t);
printf("Heutiges Datum und Uhrzeit ist: %s\n", ctime(&t));
70
KAPITEL 4. FUNKTIONEN
return 0;
}
4.25. DIFFTIME()
4.25
difftime()
Name
:
difftime — berechnet den Unterschied zwischen zwei Zeitangaben in Sekunden.
(ANSI)
Benutzung
:
double difftime(time t2, time t1);
Prototyp in
:
<time.h>
Beschreibung :
difftime() (difference time) berechnet die Differenz time2 - time1 in Sekunden.
Der datentyp time t ist in time.h als long definiert. Ein entsprechender Wert wird von der Funktion time() geliefert.
Return-Wert: :
Die Funktion liefert die Differenz time2 - time1 als double-Wert
zurück.
Querverweis :
asctime localtime timezone
ctime gmtime time
Beispiel
time t start, stop;
long i;
:
printf(“ Ich arbeite ... \n“);
time(&start);
for (i=1; i <= 5000000; i++)
;
time(&stop);
printf(Fertig nach %.0f Sekunden \n“, difftime(stop,start));
Ergebnis
UNIX
:
:
Solaris 2.x : wie oben
SunOS 4.1.x : nicht vorhanden
71
72
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion difftime()
#include
#include
#include
#include
<time.h>
<stdio.h>
<dos.h>
<conio.h>
int main(void)
{
time_t first, second;
printf("Einen Moment bitte...\n");
first = time(NULL); /* liest die Systemuhr
*/
delay(2000);
/* wartet 2 Sekunden */
second = time(NULL); /* liest noch einmal
die Systemuhr */
printf("Die Zeitdifferenz betraegt %f "
"Sekunden.\n",difftime(second,first));
printf("Druecken Sie eine Taste!");
getch();
return 0;
}
4.26. DISABLE()
4.26
73
disable()
Name
:
disable — unterdrückt Hardware-Interrupts.
Benutzung
:
void disable(void);
Prototyp in
:
<dos.h>
Beschreibung :
disable() (disable) unterdrückt alle Hardware-Interrupts außer
NMI bis zum nächsten Aufruf von enable.
Return-Wert: :
keiner
Querverweis :
enable getvect
Beispiel
:
long BILDSCHIRM = 0xB8000000;
char *Text = “Test-disable“;
unsigned char Farbe = 13;
char far *Bildschirmadresse;
(long) Bildschirmadresse = BILDSCHIRM;
disable();
while (*Text != 0) {
*Bildschirmadresse++ = *Text++;
*Bildschirmadresse++ = Farbe;
} /* end while */
enable();
Ergebnis
:
Test-disable (in violett)
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
74
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion disable()
/***ACHTUNG: Dies ist eine Interrupt Serviceroutine. Wenn Sie dieses Programm
mit Test stack overflow eingeschaltet compilieren, erhalten Sie keine korrekte
ausfuehrbare Datei. */
#include <stdio.h>
#include <dos.h>
#include <conio.h>
#define INTR 0x1C
/* Der Timer-Interrupt */
typedef void interrupt (far *isr)(...);
isr oldhandler;
int zaehler=0;
void interrupt handler(void)
{
/* alle Interrupts waehrend der Behandlung
des Timer-Interrupts unterdruecken */
disable();
/* globalen Zaehler hochzaehlen */
zaehler++;
/* Interrupts am Ende des Handlers wieder einschalten */
enable();
/* alte Routine aufrufen */
oldhandler();
}
int main(void)
{
/* alten Interrupt-Vektor speichern */
oldhandler = (isr) getvect(INTR);
/* neuen Interrupt-Handler installieren */
setvect(INTR, (isr) handler);
/* Warteschleife, bis zaehler (vom
Timer-Interrupt) auf 20 hochgezaehlt wird */
while (zaehler < 20)
printf("Der Zaehler steht auf: %d\n", zaehler);
/* installiert wieder den alten Interrupt-Handler */
setvect(INTR, oldhandler);
return 0;
}
4.27. DIV()
4.27
75
div()
Name
:
div — dividiert zwei Integerwerte und liefert den Quotienten sowie
den Rest über eine Struktur zurück.
(ANSI)
Benutzung
:
div t div(int x, int y);
Prototyp in
:
<stdlib.h>
Beschreibung :
div() divide dividiert x durch y und legt den ganzzahligen Anteil des
Ergebnisses sowie den Divisionsrest in einer Struktur vom Type div t
ab. Dieser Strukturtyp ist in der Header-Datei stdlib.h wie folgt definiert:
typedef struct {
int qout;
int rem;
} div t;
Für die Division von long-Werten kann die Funktion ldiv() verwendet
werden.
Return-Wert: :
Die Funktion liefert das Ergebnis als Struktur vom Typ div t.
Querverweis
Beispiel
:
:
Ergebnis
UNIX
:
:
ldiv
div t ergeb;
int = x;
printf(“%d \n“,div(x));
2
Solaris 2.x : wie oben
SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion div()
/* div-Beispiel */
#include <stdlib.h>
#include <stdio.h>
div_t x;
int main(void)
{
x = div(10,3);
printf("10 geteilt durch 3 = %d Rest %d.\n",
x.quot, x.rem);
return 0;
}
76
4.28
KAPITEL 4. FUNKTIONEN
ecvt()
Name
:
ecvt — wandelt eine Gleitpunktzahl in eine Zeichenkette um.
Benutzung
:
char *ecvt(double wert, int anzahl,
int *dez pkt, int *zeichen);
Prototyp in
:
<stdlib.h>
Beschreibung :
ecvt() (ecvt) wandelt wert in eine mit \0 abschließende Zeichenkette
mit anzahl Zeichen um und liefert als Funktionswert den Zeiger der
Zeichenkette. Der int -Zeiger dez pkt liefert die retative Position des
Dezimalpunktes von Beginn der Zeichenkette aus gesehen (ein negativer Wert in dez pkt sagt aus, daß der Dezimalpunkt links von dem
zurückgegebenen Zeichen steht). Ist das Zeichen des Ergebnisses negativ, liefert der int-Zeiger zeichen einen Wert ungleich 0. Das letzte
Zeichen wird gerundet.
Return-Wert: :
Zeiger auf Zeichenkette
Querverweis
:
gcvt
Beispiel
:
char *str;
double zahl = -1234567.89099059;
int dez pkt, zeichen;
puts(ecvt(zahl, 13, &dez pkt, &zeichen));
printf(“\n Der Punkt steht an %d.Stelle“,dez pkt);
if (zeichen != 0) {
puts(“\n Die Zahl ist negativ“);
} /* end if */
Ergebnis
:
-1234567.89099059
Der Punkt steht an 7. Stelle
Die Zahl ist negativ
UNIX
:
Solaris 2.x / SunOS 4.1.x : Headerdatei ist <floatingpoint.h>,
sonst wie oben
4.28. ECVT()
Beispiel zur Funktion ecvt()
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
char *string;
double value;
int dec, sign;
int ndig = 10;
clrscr();
value = 9.876;
string = ecvt(value, ndig, &dec, &sign);
printf("string = %s;
dec = %d; "
"sign = %d\n", string, dec, sign);
value = -123.45;
ndig= 15;
string = ecvt(value,ndig,&dec,&sign);
printf("string = %s; dec = %d; "
"sign = %d\n", string, dec, sign);
value = 0.6789e5; /* Exponentialdarstellung */
ndig = 5;
string = ecvt(value,ndig,&dec,&sign);
printf("string = %s;
dec = %d; "
"sign = %d\n", string, dec, sign);
return 0;
}
77
78
KAPITEL 4. FUNKTIONEN
4.29
enable()
Name
:
enable — aktiviert Hardware-Interrupts.
Benutzung
:
void enable(void);
Prototyp in
:
<dos.h>
Beschreibung :
enable() (enable) lässt Interrupts zu.
Return-Wert: :
keiner
Querverweis
:
disable getvect
Beispiel
:
s. disable
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion enable()
/***ACHTUNG: Dies ist eine InterruptServiceroutine. Wenn Sie dieses Programm
mit Test stack overflow eingeschaltet
compilieren, erhalten Sie keine korrekte
ausfuehrbare Datei. */
#include <stdio.h>
#include <dos.h>
#include <conio.h>
#define INTR 0x1C
/* Der Timer-Interrupt */
typedef void interrupt (far *isr)(...);
isr oldhandler;
int zaehler=0;
void interrupt handler(void)
{
/* alle Interrupts waehrend der Behandlung
des Timer-Interrupts unterdruecken */
disable();
/* globalen Zaehler hochzaehlen */
zaehler++;
/* Interrupts am Ende des Handlers wieder
4.29. ENABLE()
einschalten */
enable();
/* alte Routine aufrufen */
oldhandler();
}
int main(void)
{
/* alten Interrupt-Vektor speichern */
oldhandler = (isr) getvect(INTR);
/* neuen Interrupt-Handler installieren */
setvect(INTR, (isr) handler);
/* Warteschleife, bis zaehler (vom
Timer-Interrupt) auf 20 hochgezaehlt
wird */
while (zaehler < 20)
printf("Der Zaehler steht auf: %d\n",
zaehler);
/* installiert wieder den alten
Interrupt-Handler */
setvect(INTR, oldhandler);
return 0;
}
79
80
4.30
KAPITEL 4. FUNKTIONEN
exit()
Name
:
exit — beendet das laufende Programm.
Benutzung
:
void exit(int status);
Prototyp in
:
<stdlib.h>
(ANSI)
Beschreibung :
exit() (exit) beendet das laufende Programm. Vor dem endgültigen Abbruch werden sämtliche Dateipuffer geschrieben und offene Dateien
geschlossen.
Das Argument status ist der Exit-Code des Programms und kann vom
aufrufenden Prozeß ausgewertet werden. Üblicherweise benutzt man
den Wert 0, wenn das Programm korrekt abgelaufen ist. Ein von Null
verschiedener Wert zeigt einen Fehler an.
Im Unterschied zu der Funktion abort() bewirkt exit() eine normale
Programmbeendigung, und es wird keine Meldung ausgegeben.
Return-Wert: :
keiner
Querverweis
:
aexit abort exec keep
spawn exit signal
Beispiel
:
File *fp;
.
if ((fp = fopen(“test.dat“,“r“)) == NULL)
{
fprintf(stderr,“Datei %s kann nicht geöffnet werden \n“,“test.daty“);
exit(1);
}
UNIX
:
Solaris 2.x / SunOS 4.1.x : Headerdatei ist <unistd.h>,
sonst wie oben
4.30. EXIT()
Beispiel zur Funktion exit()
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
void done();
int status;
int main(void)
{
/* Definition einer Exit-Funktion */
atexit(done);
printf("Geben Sie 1 oder 2 ein: ");
status = getch();
/* Setzt den DOS Fehlercode */
exit(status - ’0’);
/* Hinweis: Diese Zeile wird nie
erreicht */
return 0;
}
void done()
{
printf("\nFertig! - Status = %d;\n",status-’0’);
}
81
82
4.31
KAPITEL 4. FUNKTIONEN
exp()
Name
:
exp — berechnet e hoch x.
Benutzung
:
double exp(double x); (reell)
complex exp(complex x); (komplex)
Prototyp in
:
<math.h> (reel)
<complex.h> (komplex)
(ANSI)
Beschreibung :
exp() (exponential) berechnet den Wert der Exponentialfunktion an der
Stelle x, d.h. den Wert ex . Die Zahl e=2.718281 .. ist die Eulersche Zahl.
Die Exponentialfunktion ist die Umkehrfunktion des natürlichen Logarithmus log().
Die komplexe Version ist definiert:
exp(x + yi) = exp(x) ∗ (cos(y) + i ∗ sin(y))
und wahrscheinlich nicht portierbar !
Return-Wert: :
Die Funktion gibt ex zurück. Im Fall eines Überlaufs wird HUGE VAL
zurückgegeben, und die Fehlervariable errno erhält den Wert ERANGE (= range error). Fehlerbehandlung kann ev. unter Verwendung der
Funktion matherr geändert werden.
Querverweis
:
frexp log matherr pow10
ldexp log10 pow sqrt
Beispiel
:
printf(“exp(-3.0) = %7.4f\n“,exp(-3.0));
printf(“exp(0.0) = %7.4f\n“,exp(0.0));
printf(“exp(3.0) = %7.4f\n“,exp(3.0));
Ergebnis
:
exp(-3.0) = 0.0498
exp(0.0) = 1.0000
exp(3.0) = 20.0855
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.31. EXP()
Beispiel zur Funktion exp()
#include <stdio.h>
#include <math.h>
int main(void)
{
double result;
double x = 4.0;
result = exp(x);
printf("e hoch %lf = %lf\n",
x, result);
return 0;
}
83
84
KAPITEL 4. FUNKTIONEN
4.32
fabs()
Name
:
fabs — berechnet den Absolutwert einer Gleitpunktzahl.
Benutzung
:
double fabs(double x);
Prototyp in
:
<math.h>
(ANSI)
Beschreibung :
fabs() (floating point abs) berechnet den Absolutwert der Gleitpunktzahl x. Für die Berechnung des Absolutwertes einer Zahl vom Typ int
oder long kann die Funktion abs() bzw. labs() verwendet werden.
Return-Wert: :
Der Absolutwert von x, d.h.
• x, f alls x ≥ 0,
• −x, f alls x < 0
Querverweis
Beispiel
:
:
:
abs cabs labs
printf(“fabs(-9.5) = %3.1f \n“,fabs(-9.5));
printf(“fabs(2.7) = %3.1f \n“,fabs(2.7));
Ergebnis
:
fabs(-9.5) = 9.5
fabs(2.7) = 2.7
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion fabs()
#include <stdio.h>
#include <math.h>
int main(void)
{
float zahl = -1234.0;
printf("Der absolute Betrag von %f ist: %f\n", zahl, fabs(zahl));
return 0;
}
4.33. FCLOSE()
4.33
85
fclose()
Name
:
fclose — schließt eine Datei.
Benutzung
:
int fclose(FILE *fp);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
fclose() (file close) schließt die mit dem File-Pointer fp verbundene Datei.
Falls die Datei zum Schreiben eröffnet wurde, überträgt fclose() den
Inhalt des Dateipuffers in die Datei. Der Hauptspeicherbereich des I/O-Puffers wird wieder freigegeben.
Um sämtliche vom Programm eröffneten Dateien zu schließen, kann
die Funktion fcloseall() verwendet werden.
Die Funktion exit() ruft zum Schließen noch aller Dateien fclose() auf.
Return-Wert: :
Die Funktion liefert den Wert 0, wenn die Datei geschlossen werden
konnte. Bei einem ungültigen File-Pointer wird der Wert EOF zurückgegeben.
Querverweis
:
close fcloseall fflush
flushall fopen freopen
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion fclose()
#include <string.h>
#include <stdio.h>
int main(void)
{
FILE *fp;
char buf[11] = "0123456789";
/* erzeugt eine Datei mit 10 Bytes */
fp = fopen("DUMMY.FIL", "w");
fwrite(buf, strlen(buf), 1, fp);
/* schliesst die Datei */
fclose(fp);
return 0;
}
86
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion fclose()
#include <string.h>
#include <stdio.h>
int main(void)
{
FILE *f_inp, *f_out;
char quelle[25], ziel[25];
char ch;
puts ("\nEinfaches Kopieren von Dateien\n");
printf("Name der Quelldatei :");
gets(quelle);
printf("Name der Zieldatei :");
gets(ziel);
f_inp = fopen(quelle,"r");
f_out = fopen(ziel,"w");
ch = 0;
while ((ch = getc(f_inp)) != EOF)
putc(ch, f_out);
fclose(f_inp);
fclose(f_out);
puts("Fertig !!!");
return 0;
}
4.34. FEOF()
4.34
87
feof()
Name
:
feof — überprüft, ob das Ende der Datei erreicht wurde.
Benutzung
:
int feof(FILE *fp);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
feof() (file eof) überprüft, ob das Ende der mit dem File-Pointer fp verbundene Datei erreicht wurde.
Das Dateiende wird über das Dateiende-Flag erkannt, welches bei Erreichen des Endes der Datei gesetzt wird. Das Dateiende-Flag bleibt solange gesetzt, bis eine der Funktionen rewind(), fseek(), oder clearerr()
aufgerufen wird.
Return-Wert: :
Das Makro liefert einen von 0 verschiedenen Wert, wenn das
Dateiende-Flag gesetzt ist, sonst 0.
Querverweis
:
clearerr eof ferror
perror
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
88
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion feof()
#include <stdio.h>
int main(void)
{
FILE *stream;
char ch;
/* oeffnet eine Datei zum Lesen */
if ((stream = fopen("DUMMY.DAT", "r")) == NULL)
{ perror ("Fehler bei fopen()");
exit(1);
}
/* liest ein Zeichen aus der Datei */
ch = fgetc(stream);
/* sucht nach dem Dateiende EOF */
if (feof(stream))
printf("Wir haben das Dateiende erreicht.\n");
else
printf("Dateiende noch nicht erreicht.\n");
/* schliesst die Datei */
fclose(stream);
return 0;
}
4.35. FERROR()
4.35
89
ferror()
Name
:
ferror — Fehlerüberprüfung bei Zugriff auf Datei.
Benutzung
:
int ferror(FILE *fp);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
ferror() (file error) überprüft, ob ein Schreib- oder Lesefehler beim Zugriff auf die mit dem File-Pointer fp verbundene Datei aufgetreten ist.
Ein Schreib- und Lesefehler wird über das Fehlerflag der Datei erkannt.
Nach Auftreten eines Fehlers bleibt das Fehler-Flag solange gesetzt, bis
eine der Funktionen clearerr() oder rewind() aufgerufen wird.
Return-Wert: :
Das Makro liefert einen von 0 verschiedenen Wert, wenn das FehlerFlag gesetzt ist, sonst 0.
Querverweis
:
clearerr eof feof
fopen gets perror
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
90
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion ferror()
#include <stdio.h>
int main(void)
{
FILE *stream;
char ch;
/* oeffnet eine Datei zum Schreiben */
stream = fopen("DUMMY.FIL", "w");
/* erzwingt eine Fehlerbedingung durch
Leseversuch */
ch = getc(stream);
/* Fehlertest in Dateistream */
if ferror(stream)
{
/* zeigt eine Fehlermeldung an */
printf("Fehler beim Lesen aus DUMMY.FIL\n");
/* beseitigt Fehlerbedingung und setzt
EOF-Indikator zurck */
clearerr(stream);
}
fclose(stream);
return 0;
}
4.36. FFLUSH()
4.36
91
fflush()
Name
:
fflush — Dateipuffer leeren.
Benutzung
:
int fflush(FILE *fp);
Prototyp in
:
<stdio.h>
Beschreibung :
(ANSI)
fflush() (file flush) überträgt den Inhalt des Dateipuffers der mit dem
File-Pointer fp verbundenen Datei.
• Wurde die Datei zum Schreiben eröffnet, so wird der Inhalt des
Dateipuffers in die Datei geschrieben.
• Ist die Datei zum Lesen eröffnet, so wird der Puffer geleert.
Nach dem Aufruf von fflush() bleibt die Datei eröffnet. Die Funktion
hat keine Wirkung bei ungepufferten Dateien.
Sollen die Dateipuffer aller zum Schreiben eröffneten Dateien übertragen werden, so ist die Funktion flushall() zu benutzen.
Return-Wert: :
Die Funktion liefert im Fehlerfall EOF, sonst den Wert 0 zurück.
Querverweis
:
fclose flushall
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
92
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion fflush()
#include
#include
#include
#include
<string.h>
<stdio.h>
<conio.h>
<io.h>
void flush(FILE *stream);
int main(void)
{
FILE *stream;
char msg[] = "Dies ist ein Test";
/* erzeugt eine Datei */
stream = fopen("DUMMY.FIL", "w");
/* schreibt etwas in die Datei */
fwrite(msg, strlen(msg), 1, stream);
/* clrscr(); TURBO-C */
printf("Beliebige Taste druecken, um Daten in DUMMY.FIL zu schreiben:");
getch();
/* schreibt Daten in DUMMY.FIL, ohne die Datei zu schliessen */
flush(stream);
printf("\nDatei wurde gefuellt, mit beliebiger Taste zurueck:");
getch();
return 0;
}
void flush(FILE *stream)
{
int duphandle;
/* fuellt den internen Puffer des stream */
fflush(stream);
/* erzeugt doppelten steam handle */
duphandle = dup(fileno(stream));
/* schliesst das Handle-Duplikat, um den DOS Puffer zu fuellen */
close(duphandle);
}
4.37. FGETC()
4.37
93
fgetc()
Name
:
fgetc — liest ein Zeichen aus Datei.
Benutzung
:
int fgetc(FILE *fp);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
fgetc() (file get character) liest aus der Datei, die mit dem File-Pointer
fp verbundene ist, das Zeichen von der aktuellen Position. Anschließend wird die aktuelle Position um 1 erhöht.
Die Funktion fgetc() ist wirkungsgleich mit dem Makro getc(). Die entsprechende Ausgabefunktion fputc().
Return-Wert: :
Das gelesene Zeichen wird zurückgegeben. Im Fehlerfall oder beim Erreichen des Dateiendes liefert die Funktion EOF.
Querverweis
:
fgetchar fputc getc getch
getchar getche ungetc ungetch
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
94
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion fgetc()
#include <string.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
FILE *stream;
char string[] = "Das ist ein Test!";
char ch;
/* oeffnet eine Datei zum Lesen und
Schreiben */
stream = fopen("DUMMY.FIL", "w+");
/* schreibt einen String in die Datei */
fwrite(string, strlen(string), 1, stream);
/* positioniert auf den Anfang der Datei */
fseek(stream, 0, SEEK_SET);
do
{
/* liest ein Zeichen aus der Datei */
ch = fgetc(stream);
/* gibt das Zeichen am Bildschirm
aus */
putch(ch);
} while (ch != EOF);
fclose(stream);
return 0;
}
4.38. FGETPOS()
4.38
95
fgetpos()
Name
:
fgetpos — ermittelt die aktuelle Position in der Datei.
Benutzung
:
int fgetpos(FILE *fp, fpos t *ppos);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
fgetpos() (file get position) ermittelt die aktuelle Position in der Datei,
die mit dem File-Pointer fp verbunden ist. Es wird die aktuelle Position
in die durch ppos adressierte Variable.
Dieser Wert wird von der Funktion fsetpos() verwendet, um später den
Seek-Zeiger wieder an diese Stelle zu positionieren.
Der Typ fpos t ist in stdio.h als long definiert.
Return-Wert: :
Im Fehlerfall wir ein von 0 verschiedener Wert zurückgegeben und die
Fehlervariable errno erhält den Wert EINVAL (= invalid argument)
oder EBADF (= bad file number) erhält.
Konnte die Funktion ordnungsgemäß ausgeführt werden, wird der
Wert 0 zurückgegeben.
Querverweis
:
fseek fsetpos ftell tell
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : nicht vorhanden
96
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion fgetpos()
#include <string.h>
#include <stdio.h>
int main(void)
{
FILE *stream;
char string[] = "Das ist ein Test!";
fpos_t filepos;
/* oeffnet eine Datei zum Lesen
und Schreiben */
stream = fopen("DUMMY.FIL", "w+");
/* schreibt einen String in die Datei */
fwrite(string, strlen(string), 1, stream);
/* ermittelt die Position des Dateizeigers */
fgetpos(stream, &filepos);
printf("Der Dateizeiger steht auf Byte "
"Nr.: %ld\n", filepos);
fclose(stream);
return 0;
}
4.39. FGETS()
4.39
97
fgets()
Name
:
fgets — liest ein Zeichenkette aus einer Datei.
Benutzung
:
char *fgets(char *string, int n, FILE *fp);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
fgets() (file get string) liest eine Zeichenkette aus der Datei, die mit
dem File-Pointer fp verbunden ist. Die Zeichenkette wird in den durch
string adressierten Speicherbereich mit dem String- Endezeichen \0
kopiert.
Die Funktion bricht das Einlesen ab, sobald n-1 Zeichen eingelesen
wurden oder der Zeilenvorschub \n erkannt und kopiert wurde.
Die entsprechende Ausgabefunktion ist fputs().
Return-Wert: :
Die Funktion gibt den Zeiger string, im Fehlerfall den NULL-Zeiger
zurück.
Querverweis
:
cgets fputs gets
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
98
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion fgets()
#include <string.h>
#include <stdio.h>
int main(void)
{
FILE *stream;
char string[] = "Das ist ein Test,\n"
"und das die zweite Zeile";
char msg[20];
/* oeffnet eine Datei zum Lesen
und Schreiben */
stream = fopen("DUMMY.FIL", "w+");
/* schreibt einen String in die Datei */
fwrite(string, strlen(string), 1, stream);
/* positioniert auf den Anfang
der Datei */
fseek(stream, 0, SEEK_SET);
/* liest einen String aus der Datei */
fgets(msg, strlen(string)+1, stream);
/* gibt den String am Bildschirm aus */
printf("%s", msg);
fclose(stream);
return 0;
}
4.40. FILENO()
4.40
99
fileno()
Name
:
fileno — ermittelt den File-Handle der Datei.
Benutzung
:
int fileno(FILE *fp);
Prototyp in
:
<stdio.h>
Beschreibung :
fileno() (file number) ermittelt den File-Handle der Datei, die mit dem
File-Pointer fp verbunden ist. Besitzt eine Datei mehrere File-Handles,
so wird der beim ersten Eröffnen der Datei zugewiesene File-Handle
zurückgegeben.
Return-Wert: :
Die Funktion gibt den File-Handle zurück. Bei ungültigem File-Pointer
ist der Return-Wert undefiniert.
Querverweis
:
fopen freopen
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion fileno()
#include <stdio.h>
int main(void)
{
FILE *stream;
int handle;
/* erzeugt eine Datei */
stream = fopen("DUMMY.FIL", "w");
/* liefert den Handle der ueber Stream angegebenen Datei */
handle = fileno(stream);
/* zeigt die Handlenummer an */
printf("Handlenummer: %d\n", handle);
/* schliesst die Datei */
fclose(stream);
return 0;
}
100
KAPITEL 4. FUNKTIONEN
4.41
floor()
Name
:
floor — berechnet die größte ganze Zahl, die kleiner oder gleich x ist.
(ANSI)
Benutzung
:
double floor(double x);
Prototyp in
:
<math.h>
Beschreibung :
floor() (floor = Boden) berechnet die größte ganze Zahl, die kleiner oder
gleich x ist.
Die Gegenfunktion zu floor() ist die Funktion ceil().
Return-Wert: :
Die Funktion gibt das Ergebnis als double-Wert zurück.
Querverweis
Beispiel
:
:
:
ceil fmod
printf(“floor(2.7) = %4.1f \n“,floor(2.7));
printf(“floor(-3.1) = %4.1f \n“,floor(-3.1));
Ergebnis
:
floor(2.7) = 2.0
floor(-3.1) = -3.1
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion floor()
#include <math.h>
#include <stdio.h>
int main(void)
{
double zahl = 123.54;
double ab, auf;
ab = floor(zahl);
auf = ceil(zahl);
printf("Ausgangszahl
printf("abgerundet
printf("aufgerundet
return 0;
}
%10.2lf\n", zahl);
%10.2lf\n", ab);
%10.2lf\n", auf);
4.42. FLUSHALL()
4.42
101
flushall()
Name
:
flushall — Dateipuffer aller geöffneten Dateien leeren.
Benutzung
:
int flushall(void);
Prototyp in
:
<stdio.h>
Beschreibung :
flushall() (flush all) überträgt die Inhalte aller mit File-Pointer eröffneten Dateien. Hierzu gehören auch die mit den File-Pointern stdin,
stdout,.... eröffneten Standarddateien.
Die Inhalte der Dateipuffer aller nur zum Lesen eröffneten Dateien werden gelöscht. Bei einem erneuten Lesezugriff werden neue Daten aus
der entsprechenden Datei in den Dateipuffer gelesen.
Nach dem Aufruf der Funktion bleiben alle Dateien eröffnet.
Um nur einen Dateipuffer in die entsprechende Datei zu übertragen, ist
die Funktion fflush() geeignet.
Return-Wert: :
Die Funktion liefert die Anzahl der zum Lesen bzw. Schreiben geöffneten Dateien, einschließlich der Standarddateien zurück.
Im Fehlerfall gibt es keinen speziellen Return-Wert.
Querverweis
:
fclose fcloseall fflush
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
(fflush() mit Null-Pointer hat gleiche Funktion, gibt aber keine Anzahl aus)
Beispiel zur Funktion flushall()
#include <stdio.h>
int main(void)
{
FILE *stream;
/* erzeugt eine Datei */
stream = fopen("DUMMY.FIL", "w");
/* entleert die Puffer aller offenen Streams*/
printf("%d Streams wurden aktualisiert.\n", flushall());
/* schliesst die Datei */
fclose(stream);
return 0;
}
102
KAPITEL 4. FUNKTIONEN
4.43
fmod()
Name
:
fmod — berechnet x modulo y.
Benutzung
:
double fmod(double x, double y);
Prototyp in
:
<math.h>
(ANSI)
Beschreibung :
fmod() float modulo berechnet x modulo y. Es wird der Rest der Division xy berechnet.
Return-Wert: :
Die Funktion liefert das Ergebnis der Modulo-Division als double
zurück.
Querverweis
Beispiel
:
:
ceil floor modf
double x = 9.5, y = 4.5;
printf(“fmod(%3.1f,%3.1f) = %3.1f \n“,x,y,fmod(x,y));
Ergebnis
:
fmod(9.5,4.5) = 0.5
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion fmod()
#include <stdio.h>
#include <math.h>
int main(void)
{
double x = 5.3, y = 2.0;
printf("%lf / %lf = %lf Rest %lf\n",
x, y, floor(x/y), fmod(x,y));
return 0;
}
4.44. FOPEN()
4.44
103
fopen()
Name
:
fopen — eröffnet eine Datei.
(ANSI)
Benutzung
:
FILE *fopen(const char *name, const char *modus);
Prototyp in
:
<stdio.h>
Beschreibung :
Hinweis:
:
fopen() (file open) eröffnet eine Datei mit dem Namen name und der
Zugriffsart modus. Mögliche Zugriffsarten sind:
modus
r
r+
Eröffnung
zum Lesen
zum Lesen und Schreiben
Anmerkung
Die Datei muß schon
existieren.
w
w+
zum Schreiben
zum Schreiben und Lesen
Existiert die Datei nicht,
so wird sie neu erzeugt;
sonst geht der Dateiinhalt
verloren.
a
a+
zum Schreiben ab Dateiende
zum Schreiben ab Dateiende
und Lesen
Existiert die Datei
noch nicht, so wird
sie neu erzeugt.
Nach der Eröffnung einer Datei zeigt der Seek-Zeiger in der Datei auf
das erste Byte. Bei einer im Modus a oder a+ eröffneten Datei wird der
Seek-Zeiger vor jeder Operation an das Ende der Datei positioniert. Daten in der Datei können daher nicht überschrieben werden.
Soll bei einer Datei, die Modus r+, w+, oder a+ eröffnet wurde, zwischen Lesen und Schreiben gewechselt werden, so muß zuvor einer der
Funktionen fseek(), rewind(), oder fsetpos() aufgerufen werden.
Unter CP/M, DOS, und OS/2 muß zwischen Text-und Binär-Modus
unterschieden werden. Dieses kann durch Anhängen des Buchstabens
t = Textmodus oder b = Binärmodus an den Modusstring erfolgen.
Bei Programmstart werden folgende Filepointer automatisch eröffnet:
Filepointer
stdin
stdout
stderr
Return-Wert: :
Anmerkung
Standardeingabe (Terminal)
Standardausgabe (Terminal)
Standardfehlermeldungen (Terminal)
Die Funktion liefert als Ergebnis einen Filepointer zurück, der mit der
Datei name verbunden ist. Der Datentyp FILE ist in stdio.h definiert.
Konnte die Datei nicht eröffnet werden, wird ein NULL-Zeiger zurückgegeben.
104
KAPITEL 4. FUNKTIONEN
Querverweis
:
creat fclose ferror fread freopen
fseek fwrite open rewind
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion fopen()
/* Dieses Programm erzeugt eine Sicherungskopie der Datei AUTOEXEC.BAT */
#include <stdio.h>
int main(void)
{
FILE *in, *out;
if ((in = fopen("C:\\AUTOEXEC.BAT", "rt"))== NULL)
{
fprintf(stderr, "Konnte Eingabedatei nicht oeffnen.\n");
return 1;
}
if ((out = fopen("C:\\AUTOEXEC.BAK", "wt"))== NULL)
{
fprintf(stderr, "Konnte Ausgabedatei nicht oeffnen.\n");
return 1;
}
while (!feof(in))
fputc(fgetc(in), out);
fclose(in);
fclose(out);
return 0;
}
4.45. FPRINTF()
4.45
105
fprintf()
Name
:
fprintf — schreibt formatiert in eine Datei.
Benutzung
:
int fprintf(FILE *fp, const *formatstring, arg1, arg2, . . . );
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
fprintf() (file print formatted) schreibt den Format-String formatstring
in die mit dem File-Pointer fp verbundene Datei.
Die Anzahl der Formatbezeichner und der Argumente muß gleich sein.
Formatbezeichner s. printf().
Return-Wert: :
Die Funktion liefert die Anzahl der ausgegebenen Zeichen zurück.
Im Fehlerfall wird EOF zurückgegeben.
Querverweis
Beispiel
:
:
fscanf printf putc sprintf
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion fprintf()
#include <stdio.h>
int main(void)
{
FILE *stream;
int i = 100;
char c = ’C’;
float f = 1.234;
/* oeffnet eine Datei fuer lesenden und schreibenden Zugriff */
stream = fopen("DUMMY.FIL", "w+");
/* schreibt einige Daten in die Datei */
fprintf(stream, "%d %c %f", i, c, f);
/* schliesst die Datei */
fclose(stream);
return 0;
}
106
KAPITEL 4. FUNKTIONEN
4.46
fputc()
Name
:
fputc — schreibt ein Zeichen in eine Datei.
Benutzung
:
int fputc(int c, FILE *fp);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
fputc() (file put character) schreibt das Zeichen c auf die aktuelle Position in die mit dem File-Pointer fp verbundene Datei.
Die Funktion ist wirkungsgleich mit dem Makro putc().
Die entsprechende Funktion zum Lesen aus der Datei ist fgetc().
Return-Wert: :
Die Funktion liefert das übergebene Zeichen zurück.
Im Fehlerfall wird EOF zurückgegeben.
Querverweis
Beispiel
:
:
fscanf printf putc sprintf
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion fputc()
#include <stdio.h>
int main(void)
{
char msg[] = "Hello world!\n";
int i = 0;
while (msg[i])
{
fputc(msg[i], stdout);
i++;
}
return 0;
}
4.47. FPUTS()
4.47
107
fputs()
Name
:
fputs — schreibt eine Zeichenkette in eine Datei.
Benutzung
:
int fputs(const char *string, FILE *fp);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
fputs() (file put string) schreibt die Zeichenkette string in die mit dem
File-Pointer fp verbundene Datei.
Das String-Endezeichen \0 wird nicht mit in die Datei übertragen.
Die entsprechende Funktion zum Lesen aus der Datei ist fgets().
Return-Wert: :
Die Funktion liefert einen von EOF verschiedenen Wert zurück.
Im Fehlerfall wird EOF zurückgegeben.
Querverweis
Beispiel
:
:
fgets gets puts
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion fputs()
#include <stdio.h>
int main(void)
{
/* schreibt einen String zur Standardausgabe */
fputs("Hello world\n", stdout);
return 0;
}
108
4.48
KAPITEL 4. FUNKTIONEN
fread()
Name
:
fread — liest Daten aus einer Datei.
Benutzung
:
size t fread(void *buffer, size t size, size t n, FILE *fp);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
fread() (file read) liest bis zu n-Datenobjekte der Länge size aus der
mit dem File-Pointer fp verbundene Datei in den Speicherbereich, auf
dem buffer zeigt.
Der Speicherbereich muß mindestens n*sizes Bytes groß sein.
Der Datentyp size t ist in stdio.h als unsigned vereinbart.
Die Gegenfunktion zu fread() ist fwrite().
Return-Wert: :
Die Funktion liefert die tatsächlich eingelesenen Datenobjekte zurück.
Ist die Anzahl kleiner als n, so wurde entweder das Dateiende erreicht
oder es trat ein Fehler auf. Zur Unterscheidung sollte eine der Funktionen feof() oder ferror() verwendet werden.
Querverweis
Beispiel
:
:
fopen fwrite printf read
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.48. FREAD()
Beispiel zur Funktion fread()
#include <string.h>
#include <stdio.h>
int main(void)
{
FILE *stream;
char msg[] = "Das ist ein Test!\n";
char buf[20];
if ((stream = fopen("DUMMY.FIL", "w+"))
== NULL)
{
fprintf(stderr, "Konnte Ausgabedatei "
"nicht oeffnen.\n");
return 1;
}
/* schreibt einige Daten in die Datei */
fwrite(msg, strlen(msg)+1, 1, stream);
/* positioniert auf den Anfang der Datei */
fseek(stream, SEEK_SET, 0);
/* liest die Daten und gibt sie am
Bildschirm aus */
fread(buf, strlen(msg)+1, 1, stream);
printf("%s", buf);
fclose(stream);
return 0;
}
109
110
KAPITEL 4. FUNKTIONEN
4.49
free()
Name
:
free — gibt einen dynamisch belegten Speicherbereich frei.
Benutzung
:
void free(void *ptr);
Prototyp in
:
<stdlib.h> und <alloc.h>
(ANSI)
Beschreibung :
free (free) gibt einen Speicherbereich frei, auf dessen Anfang ptr zeigt.
Der Inhalt von ptr muß der Return-Wert einer der Funktionen malloc(),
calloc() oder realloc() sein, durch die zuvor der Speicherbereich reserviert wurde.
Falls ptr ein NULL-Zeiger ist, hat dieses keine weitere Auswirkungen.
Querverweis
Beispiel
:
:
calloc malloc realloc
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : int free(char *ptr); Rückgabe: 1 bei Erfolg, 0 bei Fehler
Beispiel zur Funktion free()
#include <string.h>
#include <stdio.h>
#include <alloc.h>
int main(void)
{
char *str;
/* reserviert Speicher fuer einen String */
str = malloc(10);
/* kopiert "Hallo" in den String */
strcpy(str, "Hallo");
/* zeigt den String an */
printf("Der String lautet %s\n", str);
/* gibt Speicher frei */
free(str);
return 0;
}
4.50. FREOPEN()
4.50
111
freopen()
Name
:
freopen — wechselt die Datei.
Benutzung
:
FILE *freopen(const char *name, const char *modus,
FILE *fp);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
freopen() (file reopen) schließt die mit dem File-Pointer fp verbundene Datei und eröffnet die Datei name mit der Zugriffsart modus unter
Verwendung des alten File-Pointers fp.
Die möglichen Zugriffsarten sind bei fopen() beschrieben.
freopen wird meistens zur Umlenkung der Ein-/Ausgabe Standardateien stdin, stdout, stderr, stdaux oder stdprn eingesetzt.
Return-Wert: :
Die Funktion gibt den File-Pointer der neu geöffneten Datei zurück, der
identisch mit dem Wert von fp ist.
Im Fehlerfall wird der NULL-Zeiger zurückgegeben.
Die ursprüngliche Datei wird immer geschlossen.
Querverweis
:
fclose fopen open
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion freopen()
#include <stdio.h>
int main(void)
{
/* leitet die Standardausgabe in eine Datei um */
if (freopen("OUTPUT.FIL", "w", stdout)== NULL)
fprintf(stderr, "Fehler beim Versuch, "
"stdout umzuleiten!\n");
/* dies wird in OUTPUT.FIL umgeleitet */
printf("Das steht in der Datei.");
/* schliesst die (umgeleitete) Standardausgabe */
fclose(stdout);
return 0;
}
112
KAPITEL 4. FUNKTIONEN
4.51
frexp()
Name
:
frexp — berechnet die Mantisse und den Exponenten einer Gleitkommazahl.
(ANSI)
Benutzung
:
double frexp(double x, int *exponent);
Prototyp in
:
<math.h>
Beschreibung :
frexp() (float remnant exponent) zerlegt die Gleitpunktzahl x in eine
Mantisse m und einen Exponenten exp zur Basis 2, nach folgender Gleichung:
• x = m ∗ 2exp
(0.5 ≤ m < 1)
Der Exponent exp wird an der durch ptr adressierten Speicherstelle abgelegt.
Falls x den Wert 0 hat, erhalten m und exp den Wert 0.
Aus der Mantisse m und den Exponenten exp kann der Wert x mithilfe
der Funktion ldexp() berechnet werden.
Return-Wert: :
Die Funktion gibt den Wert der Mantisse m zurück.
Querverweis
Beispiel
UNIX
exp, ldexp
s.u.
Solaris 2.x / SunOS 4.1.x : wie oben
:
:
:
Beispiel zur Funktion frexp()
#include <math.h>
#include <stdio.h>
int main(void)
{
double mantisse, zahl = 7.99999999;
int exponent;
mantisse = frexp(zahl, &exponent);
printf("%lf ist %lf mal 2 hoch %d\n",zahl, mantisse, exponent);
return 0;
}
4.52. FSCANF()
4.52
113
fscanf()
Name
:
fscanf — liest formatiert aus einer Datei.
Benutzung
:
int fscanf(FILE *fp, const char *formatstring,
arg1, arg2, . . . );
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
fscanf() (file scan formatted) liest Daten aus der mit dem File-Pointer
fp verbundene Datei.
Entsprechend dem Format-String formatstring erfolgt die Zuordnung
zu den entsprechenden Argumenten arg1, arg, . . . .
Der Format-String wird in der bei scanf() beschriebenen Weise gebildet.
Jedes der Argumente arg1, arg2, . . . ist ein Zeiger auf eine Variable, deren Typ mit der entsprechenden Typangabe im Format-String übereinstimmen muß.
Return-Wert: :
Die Funktion liefert die tatsächliche Anzahl der eingelesenen Datenfelder zurück.
Bei Erreichen des Dateiendes wird EOF zurückgegeben.
Querverweis
Beispiel
UNIX
atof, fprintf printf scanf sscanf
s.u.
Solaris 2.x / SunOS 4.1.x : wie oben
:
:
:
Beispiel zur Funktion fscanf()
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
int i;
printf("Geben Sie eine ganze Zahl ein: ");
/* liest einen Integer-Wert aus der Standard-Eingabedatei */
if (fscanf(stdin, "%d", &i))
printf("Dieser Integer-Wert wurde gelesen: %i\n", i);
else
{
fprintf(stderr, "Fehler beim Lesen eines Integer-Wertes von stdin.\n");
exit(1);
}
return 0;
}
114
4.53
KAPITEL 4. FUNKTIONEN
fseek()
Name
:
fseek — verschiebt den Dateizeiger in einer Datei.
Benutzung
:
int fseek(FILE *fp, long offset, int basis);
Prototyp in
:
<stdio.h>
Beschreibung :
(ANSI)
fseek() (file seek) verschiebt den Seek-Zeiger (Dateizeiger) der mit dem
File-Pointer fp verbundene Datei um offset Bytes. Die Variable basis
kann dabei folgende Werte beinhalten:
basis
0
1
2
Anmerkung
vom Dateianfang
von der aktuellen Position
vom Dateiende
Return-Wert: :
Die Funktion liefert die tatsächliche Anzahl der eingelesenen Datenfelder zurück.
Bei Erreichen des Dateiendes wird EOF zurückgegeben.
Querverweis
:
Beispiel
:
fgetpos fopen fsetpos ftell
lseek rewind tell
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben (offset vom Typ integer)
4.53. FSEEK()
Beispiel zur Funktion fseek()
#include <stdio.h>
long filesize(FILE *stream);
int main(void)
{
FILE *stream;
/* oeffnet eine Datei zum Aktualisieren fuer
lesenden und schreibenden Zugriff */
stream = fopen("MYFILE.TXT", "a+");
/* schreibt einige Daten in die Datei */
fprintf(stream, "Das ist ein Test!\n");
/* gibt die aktuelle Groesse der Datei
aus */
printf("MYFILE.TXT ist %ld Bytes gross\n",
filesize(stream));
return 0;
}
long filesize(FILE *stream)
{
long altpos, laenge;
/* speichert die aktuelle Position
des Dateizeigers */
altpos = ftell(stream);
/* positioniert ans Ende der Datei */
fseek(stream, 0L, SEEK_END);
/* speichert die Groesse der Datei */
laenge = ftell(stream);
/* setzt den Dateizeiger auf die
urspruengliche Position */
fseek(stream, altpos, SEEK_SET);
return laenge;
}
115
116
4.54
KAPITEL 4. FUNKTIONEN
fsetpos()
Name
:
fsetpos — positioniert den Dateizeiger in einer Datei.
Benutzung
:
int fsetpos(FILE *fp, const fpos t *ppos);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
fsetpos() (file set postion) setzt den Seek-Zeiger (Dateizeiger) der mit
dem File-Pointer fp verbundenen Datei an die neue Position *ppos. Die
gewünschte Position kann zuvor mit fgetpos() ermittelt werden.
Der Datentyp fpos t ist in stdio.h als long definiert.
Der Aufruf von fsetpos(fp, ppos) ist wirkungsgleich mit fseek(fp,
*ppos, 0).
Return-Wert: :
Die Funktion liefert bei erfolgreicher Durchführung den Wert 0 zurück.
Im Fehlerfall wird ein von 0 verschiedener Wert zurückgegeben und
die Fehlervariable errno erhält den Wert EINVAL (= invalid argument)
oder EBADF (= bad file number).
Querverweis
Beispiel
:
:
fgetpos fseek ftell
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : nicht vorhanden
4.54. FSETPOS()
Beispiel zur Funktion fsetpos()
#include <stdlib.h>
#include <stdio.h>
void showpos(FILE *stream);
int main(void)
{
FILE *stream;
fpos_t filepos;
/* oeffnet eine Datei fuer lesenden und schreibenden Zugriff */
stream = fopen("DUMMY.FIL", "w+");
/* speichert die Position des Dateizeigers */
fgetpos(stream, &filepos);
/* schreibt einige Daten in die Datei */
fprintf(stream, "Das ist ein Test!\n");
/* zeigt die aktuelle Position des Dateizeigers */
showpos(stream);
/* setzt eine neue Position und zeigt sie an */
if (fsetpos(stream, &filepos) == 0)
showpos(stream);
else
{
fprintf(stderr, "Fehler beim Setzen " "des Dateizeigers.\n");
exit(1);
}
/* schliesst die Datei */
fclose(stream);
return 0;
}
void showpos(FILE *stream)
{
fpos_t pos;
/* zeigt die aktuelle Position des Dateizeigers eines Streams */
fgetpos(stream, &pos);
printf("Position des Dateizeigers: %ld\n", pos);
}
117
118
KAPITEL 4. FUNKTIONEN
4.55
ftell()
Name
:
ftell — ermittelt den aktuellen Dateizeiger.
Benutzung
:
long ftell(FILE *fp);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
ftell() (file tell) ermittelt die aktuelle Position des Dateizeigers der mit
dem File-Pointer fp verbundene Datei.
Die Position wird als long-Funktionswert zurückgegeben und gibt den
Abstand zum Dateianfang in Bytes an.
Return-Wert: :
Die Funktion liefert die aktuelle Position (= Wert des Dateizeigers)
zurück.
Bei falschem File-Pointer wird der Wert -1L zurückgeliefert, und die
Fehlervariable errno wird auf EBADF (= bad file number) oder EINVAL (= ivalid argument) gesetzt.
Querverweis
:
fgetpos fseek fsetpos lseek rewind tell
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion ftell()
#include <stdio.h>
int main(void)
{
FILE *stream;
/* oeffnet eine Datei fuer lesenden und schreibenden Zugriff */
stream = fopen("MYFILE.TXT", "w+");
/* schreibt einige Daten in die Datei */
fprintf(stream, "Das ist ein Test!\n");
/* ermittelt die Position des Dateizeigers und gibt sie aus */
printf("Der Dateizeiger zeigt auf das %ld. Byte\n", ftell(stream));
return 0;
}
4.56. FWRITE()
4.56
119
fwrite()
Name
:
fwrite — schreibt Daten in eine Datei.
Benutzung
:
size t fwrite(void *buffer,size t size, size t n, FILE *fp);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
fwrite() (file write) schreibt n- Datenobjekte der Größe size aus dem
durch buffer adressierten Puffer in die Datei, die mit dem File-Pointer
fp eröffnet wurde.
Der Datentyp size t ist in stdio.h als unsigned int definiert.
Die Gegenfunktion zu fwrite() ist fread().
Return-Wert: :
Die Funktion liefert die Anzahl der Datenobjekte zurück, die tatsächlich
in die Datei geschrieben wurden. Ist die Zahl kleiner als n, so ist ein
Fehler aufgetreten.
Querverweis
:
fopen fread
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
120
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion fwrite()
#include <stdio.h>
struct mystruct
{
int i;
char ch;
};
int main(void)
{
FILE *stream;
struct mystruct s;
/* oeffnet die Datei TEST.$$$ */
if ((stream = fopen("TEST.$$$", "wb"))== NULL)
{
fprintf(stderr, "Kann Ausgabedatei nicht oeffnen.\n");
return 1;
}
s.i = 0;
s.ch = ’A’;
/* schreibt struct s in Datei */
fwrite(&s, sizeof(s), 1, stream);
/* schliesst Datei */
fclose(stream);
return 0;
}
4.57. GENINTERRUPT()
4.57
geninterrupt()
Name
:
geninterrupt — erzeugt einen Software- Interrupt.
Benutzung
:
void geninterrupt(int intr num);
Prototyp in
:
<dos.h>
Beschreibung :
geninterrupt() (geninterrupt) löst einen Software-Interrupt für den Interrupt intr num aus.
Hinweis :
Interrupts können Register, die von C verwendet werden, in einem
nicht vorhersehbaren Zustand zurücklassen.
Return-Wert: :
Keiner
Querverweis
:
bdos disable enable getvect
int86 int86x intr
Beispiel
:
geninterrupt(0); /* Intr. für Divisionsfehler */
Ergebnis
UNIX
:
:
Divide error
nicht vorhanden
121
122
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion geninterrupt()
#include <conio.h>
#include <dos.h>
void writechar(char ch);
int main(void)
{
clrscr();
gotoxy(80,25);
/* schreibt ein Zeichen in die rechte untere Ecke,
ohne anschliessend den Bildschirm zu scrollen */
writechar(’*’);
/* wartet auf einen Tastendruck */
getch();
return 0;
}
/*
die Funktion writechar gibt an der aktuellen
Cursorposition ein Zeichen aus und vermeidet
durch die Verwendung des Video-BIOS, dass der
Bildschirm nach oben scrollt, wenn an die
Stelle (80,25) geschrieben wird.
*/
void writechar(char ch)
{
struct text_info ti;
/* ermittelt die aktuellen Texteinstellungen */
gettextinfo(&ti);
/* Interrupt 0x10 Subfunktion 9 */
_AH = 9;
/* auszugebendes Zeichen */
_AL = ch;
_BH = 0;
/* Bildschirmseite */
_BL = ti.attribute; /* Textattribut */
_CX = 1;
/* Wiederholungsfaktor */
/* gibt das Zeichen aus */
geninterrupt(0x10);
}
4.58. GETC(), GETCHAR()
4.58
123
getc(), getchar()
Name
:
getc, getchar — liest ein Zeichen aus Datei.
Benutzung
:
int getc(FILE *fp);
int getchar(void);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
getc() (get character) liest ein Zeichen aus der mit dem File-Pointer fp
verbundenen Datei.
Das Makro getchar() ist wirkungsgleich mit getc(stdin), welches das
nächste Zeichen von Standardeingabe liest.
Das Makro getc() ist wirkungsgleich mit fegtc().
Die entsprechenden Makros für die Ausgabe sind putc() und putchar().
Return-Wert: :
Die Funktion liefert das eingelesene Zeichen zurück.
Der Return-Wert EOF zeigt einen Fehler oder das Dateiende an.
Querverweis
:
fgetc getch getchar getche gets puts putchar
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion getc()
#include <stdio.h>
int main(void)
{
char ch;
printf("Geben Sie ein Zeichen ein: ");
/* liest ein Zeichen von der Standardeingabe */
ch = getc(stdin);
printf("Dies ist das eingegebene Zeichen: ’%c’\n", ch);
return 0;
}
124
KAPITEL 4. FUNKTIONEN
4.59
getcbrk()
Name
:
getcbrk — ermittelt Ctrl-Break-Flag.
Benutzung
:
int getcbrk(void);
Prototyp in
:
<stdio.h>
Beschreibung :
getcbrk() (get control break) verwendet den DOS-Systemaufruf 0x33,
um zu ermitteln, wann DOS auf Ctrl-Break prüft.
Return-Wert: :
Die Funktion liefert den Wert 0 zurück, wenn die Überprüfung abgeschaltet ist, sont den Wert 1.
Querverweis
:
ctrlbrk setcbrk
Beispiel
:
s.u.
UNIX
:
nicht vorhanden
Beispiel zur Funktion getcbrk()
#include <stdio.h>
#include <dos.h>
int main(void)
{
if (getcbrk())
printf("Ctrl-Break ist "
"eingeschaltet.\n");
else
printf("Ctrl-Break ist "
"ausgeschaltet \n");
return 0;
}
4.60. GETCH(), GETCHE()
4.60
getch(), getche()
Name
:
getch, getche — liest ein Zeichen von Tastatur.
Benutzung
:
int getch(void);
int getche(void);
Prototyp in
:
<stdio.h>
Beschreibung :
getch() und getche() (get character) lesen ein Zeichen direkt von der
Tastatur.
getch() gibt das Zeichen nicht auf dem Bildschirm aus. getche() gibt
das Zeichen auf dem Bildschirm aus.
Das Zeichen Ctrl-Z wird nicht als Dateiende interpretiert. Die Eingabe
von Ctrl-C löst den Interrupt 0x23 (= Break) aus (DOS). Mit ungetc()
kann das zuletzt gelesene Zeichen zurückgestellt werden.
Return-Wert: :
Die Funktionen liefern den ASC-Wert des eingelesenen Zeichens
zurück. Es gibt keinen speziellen Return-Wert für das Dateiende oder
für den Fehlerfall.
Querverweis
:
cgets cscanf fgetc getc getchar getche
getpass kbhit putch ungetch
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : Headerdatei ist <curses.h>;
getche() nicht vorhanden;
Sonderfunktion “Ctrl - d“.
125
126
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion getch()
#include <conio.h>
#include <stdio.h>
int main(void)
{
int c;
int extended = 0;
printf("Druecken Sie eine Taste!\n");
c = getch();
if (!c)
extended = getch();
if (extended)
printf("Erweiterter IBM-Code: %d\n", extended);
else
printf("ASCII-Code Nr.: %d\n", c);
getch();
return 0;
}
4.61. GETCURDIR()
4.61
127
getcurdir()
Name
:
getcurdir — ermittelt das aktuelle Verzeichnis eines Laufwerkes.
Benutzung
:
int getcurdir(int laufwerk, char *directory);
Prototyp in
:
<dir.h>
Beschreibung :
getcurdir() (get current directory) ermittelt das aktuelle Verzeichnis für
das angegebene Laufwerk.
directory zeigt auf die Zeichenkette mit der Länge MAXDIR, welche
den Verzeichnisnamen mit einem \0 enthält. Die Laufwerksbezeichnung ist nicht enthalten, ebenso fehlt das Zeichen \ am Anfang.
laufwerk
0
1
2
...
Bedeutung
für das aktuelle Laufwerk
für das Laufwerk A
für das Laufwerk B
usw.
Return-Wert: :
Die Funktion liefert bei fehlerfreier Durchführung den Wert 0, sonst -1.
Querverweis
:
chdir getcwd getdisk mkdir rmdir
Beispiel
:
s.u.
UNIX
:
128
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion getcurdir()
#include <dir.h>
#include <stdio.h>
#include <string.h>
char *current_directory(char *path)
{
/* Fllt den String mit X:\ */
strcpy(path, "X:\\");
/* ersetzt das X durch den Buchstaben des
aktuellen Laufwerks */
path[0] = ’A’ + getdisk();
/* fuellt den Rest des Strings mit dem
aktuellen Directory */
getcurdir(0, path+3);
return(path);
}
int main(void)
{
char curdir[MAXPATH];
current_directory(curdir);
printf("Das aktuelle Directory ist %s\n",
curdir);
return 0;
}
4.62. GETCWD()
4.62
129
getcwd()
Name
:
getcwd — ermittelt das aktuelle Arbeitsverzeichnis eines Laufwerkes.
Benutzung
:
char *getcwd(char *buf, int buflen);
Prototyp in
:
<dir.h>
Beschreibung :
getcwd() (get current working directory) ermittelt das aktuelle Arbeitsverzeichnis mit Laufwerksangabe bezüglich der Größe buflen. Ist
der vollständige Pfadname länger (einschließlich des 0-Zeichens) als
buflen-Bytes, wird ein Fehler erzeugt.
Return-Wert: :
Die Funktion liefert folgende Werte zurück:
• Ist buf bei der Eingabe ungleich NULL, wird bei fehlerfreier
Ausführung buf, im Fehlerfall NULL zurückgegeben.
• Ist buf bei der Eingabe gleich NULL, wird bei fehlerfreier
Ausführung einen Zeiger auf den belegten String zurückgegeben. Im Fehlerfall wird errno auf einen der folgenden Werte gesetzt
Wert
ENODEV
ENOMEM
ERANGE
Bedeutung
Gerät nicht bereit/nicht vorhanden
nicht genug Platz im Hauptspeicher
Ergebnis außerhalb des Bereichs
Querverweis
:
chdir getcurdir mkdir rmdir
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : Headerdatei ist <unistd.h>,
sonst wie oben
130
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion getcwd()
#include <stdio.h>
#include <dir.h>
#include <conio.h>
int main(void)
{
char buffer[MAXPATH];
/* ermittelt das aktuelle Directory#include <dir.h>
#include <conio.h>
und zeigt es an */
getcwd(buffer, MAXPATH);
printf("Das aktuelle Directory ist: %s\n",
buffer);
getch();
return 0;
}
4.63. GETDATE()
4.63
getdate()
Name
:
getdate — ermittelt das aktuelle Datum.
Benutzung
:
void getdate(struct date *datum);
Prototyp in
:
<dos.h>
Beschreibung :
getdate() (get datum) ermittelt das aktuelle Datum und kopiert die
Werte in die dafür vorgesehene Struktur.
Der Strukturtyp date ist in dos.h wie folgt definiert:
struct date
{
int da year; /* aktuelles Jahr */
char da day; /* Tag im Monat (1-31 */
char da mon; /* Monat (1-12) */ };
Return-Wert: :
Keiner
Querverweis
:
ctime gettime setdate settime
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : getdate() vorhanden, aber mit anderer Funktion
SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion getdate()
#include <dos.h>
#include <stdio.h>
int main(void)
{
struct date d;
getdate(&d);
printf("Tag:
%d\n"
"Monat: %d\n"
"Jahr: %d\n",
d.da_day, d.da_mon, d.da_year);
return 0;
}
131
132
4.64
KAPITEL 4. FUNKTIONEN
getdfree()
Name
:
getdfree — ermittelt den freien Platz auf einer Diskette/Festplatte.
Benutzung
:
void getdfree(unsigned char laufwerk,
struct dfree *dtable);
Prototyp in
:
<dos.h>
Beschreibung :
getdfree() (get disk free space) ermittelt den freien Platz auf dem durch
laufwerk angegebenen Laufwerks.
Für laufwerk können folgende Werte gesetzt werden:
laufwerk
0
1
2
...
Bedeutung
für das aktuelle Laufwerk
für das Laufwerk A
für das Laufwerk B
usw.
Der Strukturtyp dfree ist wie folgt definiert:
struct dfree
{
unsigned df avail; /* freie Cluster */
unsigned df total; /* Gesamtzahl Cluster */
unsigned df bsec; /* Byte pro Sektor */
unsigned df sclus; /* Sektoren pro Cluster */
};
Return-Wert: :
Keiner
Im Fehlerfall wird df sclus der Wert 0xFFFF zugewiesen.
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
4.64. GETDFREE()
Beispiel zur Funktion getdfree()
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<dir.h>
<dos.h>
int main(void)
{
struct dfree free;
long avail;
int drive;
drive = getdisk();
getdfree(drive+1, &free);
if (free.df_sclus == 0xFFFF)
{
printf("Fehler beim Aufruf von "
"getdfree()\n");
exit(1);
}
avail =
(long) free.df_avail *
(long) free.df_bsec *
(long) free.df_sclus;
printf("In Laufwerk %c: sind noch %ld "
"Bytes frei\n", ’A’+drive, avail);
return 0;
}
133
134
KAPITEL 4. FUNKTIONEN
4.65
getdisk()
Name
:
getdisk — ermittelt das aktuelle Laufwerk.
Benutzung
:
int getdisk(void);
Prototyp in
:
<dir.h>
Beschreibung :
getdisk() (getdisk) ermittelt das aktuelle Laufwerk.
Return-Wert: :
Die Funktion liefert die Nummer des aktuellen Laufwerkes zurück.
laufwerk
0
1
2
...
Bedeutung
für das aktuelle Laufwerk
für das Laufwerk A
für das Laufwerk B
usw.
Querverweis
:
getcurdir setdisk
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion getdisk()
#include <stdio.h>
#include <dir.h>
int main(void)
{
int disk;
disk = getdisk() + ’A’;
printf("Das aktuelle Laufwerk ist %c.\n",
disk);
return 0;
}
4.66. GETENV()
4.66
135
getenv()
Name
:
getenv — gibt Information zu einer Umgebungsvariablen aus. (ANSI)
Benutzung
:
char *getenv(const char *name);
Prototyp in
:
<stdlib.h>
Beschreibung :
getenv() (get enviroment) sucht die Tabelle der Umgebungsvariablen
nach dem zu name gehörenden Eintrag ab.
Return-Wert: :
Die Funktion liefert einen Zeiger auf den entsprechenden Eintrag
zurück. Falls kein Eintrag zu name vorhanden ist, wird der Wert NULL
zurückgegeben. (= Wert des Dateizeigers) zurück.
Querverweis
:
environ (globale Variable) getpsp putenv
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion getenv()
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
char *s;
/* die Comspec Environment-Parameter lesen */
s=getenv("COMSPEC");
/* die Parameter zeigen */
printf("Command processor: %s\n",s);
return 0;
}
136
KAPITEL 4. FUNKTIONEN
4.67
gets()
Name
:
gets — liest eine Zeichenkette von Tastatur.
Benutzung
:
char *gets(char *buffer);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
gets() (get string) liest eine Zeichenkette von der Tastatur bis zum
Newline-Zeichen \n und legt sie in dem durch buffer spezifizierten Bereich ab. Das Newline-Zeichen wird durch das String-Endezeichen \0
ersetzt.
Die Gegenfunktion ist puts().
Return-Wert: :
Die Funktion liefert bei fehlerfreier Ausführung einen Zeiger auf buffer
zurück.
Im Fehlerfall wird NULL zurückgegeben.
Querverweis
:
cgets ferror fgets fputs fread
getc puts
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion gets()
#include <stdio.h>
int main(void)
{
char string[80];
printf("Geben Sie einen String ein: ");
gets(string);
printf("Dies ist der eingegebene String: "
"%s\n", string);
return 0;
}
4.68. GETTIME()
4.68
gettime()
Name
:
gettime — ermittelt die Uhrzeit des Systems.
Benutzung
:
void gettime(struct time *timep);
Prototyp in
:
<dos.h>
Beschreibung :
gettime() (gettime) ermittelt die aktuelle Zeit unter MS-DOS und setzt
die Werte in die dafür vorgegebene Struktur.
struct time {
unsigned char ti min; /* Minuten */
unsigned char ti hour; /* Stunden */
unsigned char ti hund; /* 1/100 Sek. */
unsigned char ti sec; /* Sekunden */
};
Return-Wert: :
Keiner
Querverweis
:
getdate settime time
Beispiel
:
s.u.
UNIX
:
Solaris 2.x:
int clock gettime(clockid t clock id, struct timespec *tp)
setzt die Zeit für die durch clock id spezifizierte Uhr
mit Headerdatei <time.h>
SunOS 4.1.x : nicht vorhanden
:
Beispiel zur Funktion gettime()
#include
#include
<stdio.h>
<dos.h>
int main(void)
{
struct time t;
gettime(&t);
printf("Es ist jetzt %2d Uhr %02d Minuten "
"und %02d.%02d Sekunden.\n",
t.ti_hour, t.ti_min, t.ti_sec, t.ti_hund);
return 0;
}
137
138
4.69
KAPITEL 4. FUNKTIONEN
getvect()
Name
:
getvect — liest einen Interrupt-Vektor.
Benutzung
:
void interrupt(*getvect(int intr nummer))();
Prototyp in
:
<dos.h>
Beschreibung :
MS-DOS besitzt eine Vektortabelle für Hardware-Interrupts, die von
0 bis 255 durchnummeriert sind. Der Wert in jedem Vektor, der eine
Länge von 4 byte hat, ist die Adresse der jeweiligen Interrupt-Funktion.
getvect liest den Wert des Vektors, der durch intr nummer lokalisiert
wird, interpretiert diesen gelesenen Wert als einen Zeiger, der auf die
Interrupt-Routine zeigt.
Return-Wert: :
getvect liefert den aktuellen 4 Byte langen Wert zurück, der im
Interrupt-Vektor intr nummer gespeichert ist.
Querverweis
:
disable enable
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
4.69. GETVECT()
Beispiel zur Funktion getvect()
#include <stdio.h>
#include <dos.h>
void interrupt get_out(); /* Interruptprototyp */
void interrupt (*oldfunc)();
/* Interruptfunktionszeiger */
int looping = 1;
int main(void)
{
puts("Mit <Shift><Prt Sc> beenden");
/* speichert alten Interrupt */
oldfunc = getvect(5);
/* installiert Interrupthandler */
setvect(5,get_out);
/* nichts tun */
while (looping);
/* setzt urspruengliche Interruptroutine */
setvect(5,oldfunc);
puts("Die Operation war erfolgreich.");
return 0;
}
void interrupt get_out()
{
looping = 0;
/* veraendert die globale Variable, um die
Schleife zu verlassen */
}
139
140
4.70
KAPITEL 4. FUNKTIONEN
gmtime()
Name
:
gmtime — rechnet Datum und Uhrzeit in die Greenwich Mean Time
(GMT) um.
(ANSI)
Benutzung
:
struct tm *gmtime(const time t *sec);
Prototyp in
:
<time.h>
Beschreibung :
gmtime() (Greenwich Mean Time (GMT)) wandelt die in sec angegebene Anzahl von Sekunden, die seit dem 1. Januar 1970, 0 Uhr vergangen sind, in das entsprechende Datum mit Uhrzeit um.
Die aktuelle Anzahl der Sekunden erhält man durch einen Aufruf der
Funktion time().
Der Datentyp time t ist in time.h als long definiert.
gmtime() erzeugt eine Struktur tm und legt die Werte dort ab und ist
wie folgt definiert:
struct
tm
{
int tm
int tm
int tm
int tm
int tm
int tm
int tm
int tm
int tm
sec;
min;
hour;
mday;
mon;
year;
wday;
yday;
isdst;
};
Die Tageszeit wird in 24 Stunden gemessen, der Tag im Monat von 1 bis
31, der Monat von 0 bis 11 und der Tag Jahr von 0 bis 365. Der Wochentag beginnt mit Sonntag = 0 und zur Jahresangabe muß 1900 addiert
werden. Das Flag tm isdst gibt an, ob die Sommerzeit konvertierung
durchgeführt wurde.
Return-Wert: :
Die Funktion liefert einen Zeiger auf die Struktur vom Typ tm.
Querverweis
:
asctime ctime ftime localtime
stime time tzset
Beispiel
:
time t sec;
time(&sec);
printf(”Datum und Uhrzeit(GMT): %s \n“,
asctime(gmtime(&sec)));
Ergebnis
:
Datum und Uhrzeit (GMT): Sun Oct 16 18:46:04 1990
4.70. GMTIME()
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion gmtime()
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<time.h>
<dos.h>
/* Mitteleuropaeische Zeit & Sommerzeit */
char *tzstr = "TZ=MEZ-1MES";
int main(void)
{
time_t t;
struct tm *gmt, *area;
/* schreibt den time zone-String in
die Environment-Tabelle */
putenv(tzstr);
tzset();
t = time(NULL);
area = localtime(&t);
printf("Ortszeit: %s", asctime(area));
gmt = gmtime(&t);
printf("Greenwich: %s", asctime(gmt));
return 0;
}
141
142
4.71
KAPITEL 4. FUNKTIONEN
harderr()
Name
:
harderr — installiert einen Hardware- Error-Handler.
Benutzung
:
void harderr(int (*handler)());
Prototyp in
:
<dos.h>
Beschreibung :
harderr() (harderr) installiert für das aktuelle Programm eine Fehlerbehandlungsroutine. Diese Routine wird bei jedem Auftreten eines Interrupt 0x24 aufgerufen.
Es wird dabei die Funktion, auf die handler zeigt, aufgerufen. Diese
wird wie folgt aufgerufen:
handler(int errval, int ax, int bp, int si);
errval
: ist der von DOS übergebene Fehlercode.
ax, bp, si : enthalten die Registerwerte AX, BP, SI.
ax hat folgende Bedeutung:
• ax ≥ 0 = Diskettenfehler
Mit der Operation ax & 0x00FF erhält man die Nummer des Laufwerks:
laufwerk
1
2
3
...
Bedeutung
für das Laufwerk A
für das Laufwerk B
für das Laufwerk C
usw.
• ax < 0 = Gerätefehler
bp und si zeigen zusammen auf den Header des Gerätetreibers,
in dem der Fehler aufgetreten ist.
bp enthält die Segmentadresse,
si ist der Offset.
Die Funktion, auf die handler zeigt wird nicht direkt aufgerufen. harderr installiert einen DOS-Interrupt-Vektor, der diese Funktion aufruft.
Rückgabewerte von handler :
• 0 für Ignorieren
• 1 für Wiederholen
• 2 für Abbruch
Return-Wert: :
Keiner
Querverweis
:
hardresume hardretn
Beispiel
:
s.u.
4.71. HARDERR()
UNIX
:
143
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion harderr()
/* Dieses Programm faengt Diskettenfehler
fordert den Benutzer zu einer Aktion
Lassen Sie das Programm laufen, ohne
Diskette in Laufwerk A: eingelegt zu
*/
ab und
auf.
eine
haben.
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#define IGNORE
#define RETRY
#define ABORT
0
1
2
int buf[500];
/* definiert Fehlermeldungen, die
Diskettenprobleme beschreiben
/
*
static char *err_msg[] = {
"Diskette ist schreibgeschuetzt",
"unbekannte Einheit",
"Laufwerk nicht bereit",
"unbekanntes Kommando",
"Datenfehler (CRC)",
"falsche Laenge (Request-Struktur)",
"Suchfehler",
"unbekannter Mediumstyp",
"Sektor nicht gefunden",
"Drucker hat kein Papier",
"Schreibfehler",
"Lesefehler",
"allgemeiner Fehler",
"unbekannter Fehler",
"unbekannter Fehler",
"ungueltiger Diskettenwechsel"
};
error_win(char *msg)
{
int retval;
cputs(msg);
/* fordert den Anwender auf, eine Taste
144
KAPITEL 4. FUNKTIONEN
zu druecken, um abzubrechen, zu
wiederholen oder zu ignorieren */
while(1)
{
retval= getch();
if (retval == ’a’ || retval == ’A’)
{
retval = ABORT;
break;
}
if (retval == ’w’ || retval == ’W’)
{
retval = RETRY;
break;
}
if (retval == ’i’ || retval == ’I’)
{
retval = IGNORE;
break;
}
}
return(retval);
}
/* Das Pragma warn -par unterdrueckt die
Warnungen des Compilers, die sich auf
die Nichtbenutzung der Parameter
errval, bp und si von handler beziehen.
/
*
#pragma warn -par
int handler(int errval,int ax,int bp,int si)
{
static char msg[200];
unsigned di;
int drive;
int errorno;
di= _DI;
/* falls es sich nicht um einen Diskettenfehler handelt, gibt es Probleme mit
einer anderen logischen Geraeteeinheit
*/
if (ax < 0)
{
/* meldet den Fehler */
error_win("Geraetefehler");
4.71. HARDERR()
/* zurueck zum Programm, das sofort
abgebrochen werden soll */
hardretn(ABORT);
}
/* es war ein Diskettenfehler */
drive = ax & 0x00FF;
errorno = di & 0x00FF;
/* meldet, um welchen Fehler
es sich handelt */
sprintf(msg,
"Fehler bei Laufwerk %c: %s!\r\n"
"A)bbrechen, W)iederholen, "
"I)gnorieren ?\r\n",
’A’ + drive, err_msg[errorno]);
/* zurueck zum Programm mit Hilfe von
DOS-Interrupt 0x23, mit Abbrechen,
Wiederholen oder Ignorieren als
Eingabe vom Benutzer */
hardresume(error_win(msg));
return ABORT;
}
#pragma warn +par
int main(void)
{
/* installiert unsere Routine zur
Behandlung von Hardware-Problemen */
harderr(handler);
clrscr();
printf("oeffnen Sie die Klappe von Laufwerk A:,\n");
"und druecken Sie eine Taste...\n");
getch();
printf("Versuche auf Laufwerk A: "
"zuzugreifen...\n");
printf("fopen liefert %p\n",
fopen("A:temp.dat", "w"));
return 0;
}
145
146
4.72
KAPITEL 4. FUNKTIONEN
hardresume()
Name
:
hardresume — Hardware-Fehlerbehandlungsroutine.
Benutzung
:
void hardresume(int axret);
Prototyp in
:
<dos.h>
Beschreibung :
hardresume() (hardresume) kann von der in harderr vereinbarten Fehlerbehandlungsroutine aufgerufen werden, um zu DOS zurückzukehren.
Folgende Argumente sind möglich:
axret
0
1
2
Bedeutung
für Ignorieren
für Wiederholen
für Abbruch
Der Abbruch wird über einen Aufruf des DOS-Interrupts 0x23 (CtrlBreak) durchgeführt.
Return-Wert: :
Keiner
Querverweis
:
harderr hardretn
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion hardresume()
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#define IGNORE
#define RETRY
#define ABORT
0
1
2
int buf[500];
/* define the error messages for trapping disk problems */
static char *err_msg[] = {
"schreibgeschuetzt",
"unbekanntes Medium",
4.72. HARDRESUME()
147
"Diskette/Laufwerk nicht bereit",
"unbekannter Befehl",
"Datenfehler (CRC)",
"ungueltiger Aufruf",
"Suchfehler",
"unbekannter Platten/Diskettentyp",
"Sektor nicht gefunden",
"Papier fehlt",
"Schreibfehler",
"Lesefehler",
"Allgemeine Fehlerbedingung",
"reserviert",
"reserviert",
"Diskettenwechsel unzulaessig" };
error_win(char *msg)
{
int retval;
cputs(msg);
/* Eingabeaufforderung an Benutzer, ob abbrechen, wiederholen
oder ignorieren */
while(1)
{
retval= getch();
if (retval == ’a’ || retval == ’A’)
{
retval = ABORT;
break;
}
if (retval == ’w’ || retval == ’W’) {
if (retval == ’i’ || retval == ’I’) {
}
retval = RETRY;
retval = IGNORE;
break;
break;
return(retval);
}
/* pragma warn -par reduziert die Warnungen, die aufgrund des */
/* fehlenden Parameter errval, bp und si auftauchen koennen und */
/* gibt "Parameter never used" aus */
#pragma warn -par
int handler(int errval,int ax,int bp,int si)
{
static char msg[80];
unsigned di;
int drive;
int errorno;
}
}
148
KAPITEL 4. FUNKTIONEN
di= _DI;
/* falls es sich nicht um einen Diskettenfehler gehandelt hat,
*/
/* wurde das Problem von einer anderen Geraeteeinheit verursacht. */
/*
/*
/*
/*
if (ax < 0)
{
/* meldet den Fehler */
error_win("Fehler an Geraeteeinheit");
/* und gibt direkt an das Programm zurueck mit der */
/* Aufforderung abzubrechen */
hardretn(ABORT);
}
anderenfalls handelt es sich um einen Disketten/Laufwerksfehler */
drive = ax & 0x00FF;
errorno = di & 0x00FF;
meldet den Fehler */
sprintf(msg, "Fehler: %s Laufwerk %c\r\nA)bbrechen, W)iederholen,
I)gnorieren: ",
err_msg[errorno], ’A’ + drive);
uebergabe an das Programm ueber den DOS-Interrupt 0x23 mit der Benutzer- */
eingabe Abbrechen, Wiederholen oder Ignorieren.
*/
hardresume(error_win(msg));
return ABORT;
}
#pragma warn +par
int main(void)
{
/* setzt den Hardwarefehler-Interruptvektor 0x24 auf die durch handler */
/* angegebene C-Routine */
harderr(handler);
clrscr();
printf("Versichern Sie sich, dass sich keine Diskette in Laufwerk A:
befindet\n");
printf("Druecken Sie eine Taste ....\n");
getch();
printf("Versuch, auf Laufwerk A: zuzugreifen:\n");
printf("fopen ergibt %p\n",fopen("A:temp.dat", "w"));
return 0;
}
4.73. HARDRETN()
4.73
149
hardretn()
Name
:
hardretn — Hardware-Fehlerbehandlungsroutine.
Benutzung
:
void hardretn(int retn);
Prototyp in
:
<dos.h>
Beschreibung :
Die von harderr installierte Fehlerbehandlungsroutine kann mit einem
Aufruf von hardretn() direkt zum Anwenderprogramm zurückkehren.
Der Rückgabewert der DOS-Funktion, die den Hardware- Fehler
auslöst, ist der Wert, der an hardretn() übergeben wurde.
Return-Wert: :
Keiner
Querverweis
:
harderr hardresume
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion hardretn()
/* Dieses Programm faengt Diskettenfehler ab und
fordert den Benutzer zu einer Aktion auf.
Lassen Sie das Programm laufen, ohne eine
Diskette in Laufwerk A: eingelegt zu haben.
/
*
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#define IGNORE
#define RETRY
#define ABORT
0
1
2
int buf[500];
/* definiert Fehlermeldungen, die
Diskettenprobleme beschreiben
/
*
static char *err_msg[] = {
"Diskette ist schreibgeschuetzt",
"unbekannte Einheit",
150
KAPITEL 4. FUNKTIONEN
"Laufwerk nicht bereit",
"unbekanntes Kommando",
"Datenfehler (CRC)",
"falsche Laenge (Request-Struktur)",
"Suchfehler",
"unbekannter Mediumstyp",
"Sektor nicht gefunden",
"Drucker hat kein Papier",
"Schreibfehler",
"Lesefehler",
"allgemeiner Fehler",
"unbekannter Fehler",
"unbekannter Fehler",
"ungueltiger Diskettenwechsel"
};
void error_win(char *msg)
{
cputs(msg);
}
/* Das Pragma warn -par unterdrueckt die
Warnungen des Compilers, die sich auf
die Nichtbenutzung der Parameter
errval, bp und si von handler beziehen.
/
*
#pragma warn -par
int handler(int errval,int ax,int bp,int si)
{
static char msg[200];
unsigned di;
int drive;
int errorno;
di= _DI;
/* falls es sich nicht um einen Diskettenfehler handelt, gibt es Probleme mit
einer anderen logischen Geraeteeinheit
*/
if (ax < 0)
{
/* meldet den Fehler */
error_win("Geraetefehler");
/* zurueck zum Programm, das sofort
abgebrochen werden soll */
hardretn(ABORT);
}
4.73. HARDRETN()
/* es war ein Diskettenfehler */
drive = ax & 0x00FF;
errorno = di & 0x00FF;
/* meldet, um welchen Fehler
es sich handelt */
sprintf(msg,
"Fehler bei Laufwerk %c: %s!\r\n",
’A’ + drive, err_msg[errorno]);
error_win(msg);
/* zurueck zum Programm mit Hilfe von
DOS-Interrupt 0x23
/
*
hardretn(ABORT);
return ABORT;
}
#pragma warn +par
int main(void)
{
/* installiert unsere Routine zur
Behandlung von Hardware-Problemen */
harderr(handler);
clrscr();
printf("Oeffnen Sie die Klappe von Laufwerk "
"A:,\und druecken Sie eine Taste...\n");
getch();
printf("Versuche auf Laufwerk A: "
"zuzugreifen...\n");
printf("fopen liefert %p\n",
fopen("A:temp.dat", "w"));
return 0;
}
151
152
4.74
KAPITEL 4. FUNKTIONEN
inp(),outp()
Name
:
inp,outp — lesen/schreiben von/auf Port-Adresse.
Benutzung
:
int inp(unsigned port); /* Lese von Port */
void outp(unsigned port, int byte); /* Schreiben auf Port */
Prototyp in
:
<conio.h> /* Für Microsoft-C: Prototypen */
<dos.h> /* Für TURBO-C : Makro-Definitionen */
Beschreibung :
inp() (in port) liest einzelnes Byte von durch port angegebene PortAdresse.
outp() (out port) schreibt ein einzelnes Byte, den Wert von byte in die
Port Adresse port.
Return-Wert: :
Die Funktion inp() liefert das gelesene Byte zurück.
Querverweis
:
outp inport inportb outport outportb
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion inp(),outp()
int printchar( int c) /* Zeichen c an Drucker LPT1 senden */
{
unsigned port = *(unsigned far *)0x00000408L; /* Port-Adresse */
/* im BIOS-Datenbereich lesen.*/
unsigned long time = 0xFFFFF;
/* Wert fuer TIME-OUT */
outp(port, c & 0xFF)
++port;
while( !(inp(port) & 0x80))
if (--time == 0) return 0;
}
/*
/*
/*
/*
Zeichen -> Daten-Port */
Status-Port
*/
Warten, bis Drucker bereit */
TIME OUT Fehler */
++port;
outp(port, 0xD);
outp(port, 0xC);
/* Steuer-Port
*/
/* Zeichen an Drucker schicken */
/* Bit 0 = Strobe: high, dann low. */
return 1;
/* Kein Fehler
*/
4.75. INT86(),INT86X()
4.75
int86(),int86x()
Name
:
int86,int86x — Genereller 8086-Softwareinterrupt.
Benutzung
:
int int86(int intno, union REGS *inregs,
union REGS *outregs);
int int86x(int intno, union REGS *inregs,
union REGS *outregs, struct SREGS *segregs);
Prototyp in
:
<dos.h>
Beschreibung :
int86() und int86x(),(interrupt 86) führen einen Software-Interrupt, der
durch intno gegeben ist. Die Argumente inregs und outregs sind Zeiger auf Unions vom Typ REGS, der in dos.h definiert ist.
Vor dem Systemaufruf werden die Inhalte der durch inregs adressierten Union in die entsprechenden Register geladen. Nach Ausführung
des Interrupts werden die aktuellen Registerinhalte in die durch outregs adressierte Union kopiert.
Ein gesetztes Carry-Flag (in outregs das x.cflag-Feld) zeigt an, daß ein
Fehler aufgetreten ist.
inregs und outregs können die gleiche Adresse haben.
int86x() übernimmt zusätzlich Werte für die Segment-Register aus der
durch segres definierten Struktur.
Return-Wert: :
Die Funktionen geben den Wert des AX- Registers nach dem Interruptaufruf zurück.
Querverweis
:
int86x intdos intr
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
153
154
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion int86()
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#define VIDEO 0x10 /* Interrupt-Nummer */
void movetoxy(int x, int y)
{
union REGS regs;
regs.h.ah = 2;
/* Subfunktion Cursor
postionieren */
regs.h.dh = y;
regs.h.dl = x;
regs.h.bh = 0; /* Videoseite Nr. 0 */
int86(VIDEO, &regs, &regs);
}
int main(void)
{
clrscr();
movetoxy(35, 10);
printf("Hello world\n");
return 0;
}
4.76. INTDOS()
4.76
155
intdos()
Name
:
intdos — allgemeiner DOS-Funktionsaufruf.
Benutzung
:
int intdos(union REGS *inregs, union REGS *outregs);
Prototyp in
:
<dos.h>
Beschreibung :
intdos() (intdos) führt den DOS-Interrupt 0x21 aus, um eine angegebene Funktion anzusprechen. Der Wert von inregs.h.al gibt an, welche
DOS-Funktion angesprochen wird.
Nach dem Interrupt 0x21 kopiert intdos die aktuellen Registerwerte
nach outregs.
Ein gesetztes Carry-Flag (in outregs das x.cflag-Feld) zeigt an, daß ein
Fehler aufgetreten ist.
inregs und outregs können die gleiche Adresse haben.
Return-Wert: :
Die Funktion intdos liefert den Wert vom AX-Register.
Querverweis
:
geninterrupt int86 int86x intr
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
156
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion intdos()
#include <stdio.h>
#include <dos.h>
/* loescht Dateinamen; liefert bei erfolgreicher
Operation 0 zurueck, ansonsten einen Wert
ungleich Null */
int delete_file(char near *filename)
{
union REGS regs;
int ret;
/* loescht Datei */
regs.h.ah = 0x41;
regs.x.dx = (unsigned) filename;
ret = intdos(&regs, &regs);
/* Fehler, falls das Carry-Flag gesetzt
ist */
return(regs.x.cflag ? ret : 0);
}
int main(void)
{
int err;
err = delete_file("NOTEXIST.$$$");
if (!err)
printf("NOTEXIST.$$$ wurde geloescht.\n");
else
printf("NOTEXIST.$$$ kann nicht "
"geloescht werden.\n");
return 0;
}
4.77. IOCTL()
4.77
157
ioctl()
Name
:
ioctl — direkte Steuerung von Peripheriegeräten.
Benutzung
:
int ioctl(int handle, int func [,void *argdx, int argcx]);
Prototyp in
:
<io.h>
Beschreibung :
ioctl() (ioctl) verwendet unter DOS die DOS-Funktion 0x44.
Das Argument func kann folgende Werte annehmen:
func
0
1
2
3
4
5
6
7
8
11
Return-Wert: :
Bedeutung
Ermittelt die Geräteinformation
Setzen von Geräteinformation über argdx
Lese von argcx Bytes vom Gerät in den Bereich,
auf den argdx zeigt.
Schreibt von argcx Bytes zu dem Gerät, argdx
zeigt auf die Startadresse im Speicher.
Wie 2, unter Berücksichtigung von handle als
Laufwerksnummer:
laufwerk Bedeutung
0
für das aktuelle Laufwerk
1
für das Laufwerk A
2
für das Laufwerk B
...
usw.
Wie 3, unter Berücksichtigung von handle als
Laufwerksnummer.
Ermittelt den Eingabe-Status
Ermittelt den Ausgabe-Status
Prüfung, ob der Datenträger auswechselbar ist
(ab DOS 3.x)
Setzen der Anzahl der Wiederholversuche bei Kollisionen
im SHARED-Betrieb (ab DOS 3.x).
Die Funktion ioctl liefert für func
folgende Werte :
laufwerk
0,1
2,5
6,7
Fehler
Bedeutung
Geräteinformation (im DX-Register)
Anzahl der tatsächlich gelesenen/geschriebenen Bytes
Geräte-Status
-1
Querverweis
:
geninterrupt int86 int86x intr
Beispiel
:
s.u.
158
KAPITEL 4. FUNKTIONEN
UNIX
:
Solaris 2.x / SunOS 4.1.x : Parametertypen wie oben, Headerdatei ist <unistd.h>
Systemaufruf für Devices - “Files“ anwendbar.
Beispiel zur Funktion ioctl() für DOS
#include <stdio.h>
#include <dir.h>
#include <io.h>
int main(void)
{
int stat;
/* die Subfunktion 8 stellt fest, ob das
Medium im voreingestellten Laufwerk
auswechselbar ist */
stat = ioctl(0, 8, 0, 0);
if (!stat)
printf("Laufwerk %c ist austauschbar.\n",
getdisk() + ’A’);
else
printf("Laufwerk %c ist nicht "
"austauschbar.\n",
getdisk() + ’A’);
return 0;
}
4.78. ISALNUM()
4.78
159
isalnum()
Name
:
isalnum — Überprüfung alphanumerisches Zeichen.
Benutzung
:
int isalnum(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
isalnum() (is alphanumeric) überprüft, ob das Zeichen c ein alphanumerisches Zeichen ist.
’A . . . Z’,
’a . . . z’,
’0 . . . 9’
Berücksichtigt werden die Codes im ASCII-Zeichensatz von 0-127, ohne deutsche Umlaute und ß.
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn das Zeichen
alphanumerisch ist, sonst den Wert 0 (FALSE).
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion isalnum()
#include <stdio.h>
#include <ctype.h>
void main(void)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(isalnum(c))
printf("Das Zeichen %c ist alphanumerisch \n",c);
else
printf("Das Zeichen %c ist nicht alphanumerisch ! \n",c);
}
160
4.79
KAPITEL 4. FUNKTIONEN
isalpha()
Name
:
isalpha — Überprüfung alphabetisches Zeichen.
Benutzung
:
int isalpha(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
isalpha() (is alphabetic) überprüft, ob das Zeichen c ein alphabetisches
Zeichen ist
’A . . . Z’,
’a . . . z’
Berücksichtigt werden die Codes im ASC-Zeichensatzt von 0-127, ohne
deutsche Umlaute und ß.
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn das Zeichen
alphabetisch ist, sonst den Wert 0 (FALSE).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion isalpha()
#include <stdio.h>
#include <ctype.h>
void main(void)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(isalpha(c))
printf("Das Zeichen %c ist ein Buchstabe \n",c);
else
printf("Das Zeichen %c ist ein kein Buchstabe ! \n",c);
}
4.80. ISASCII()
4.80
161
isascii()
Name
:
isascii — Überprüfung ASCII-Zeichen.
Benutzung
:
int isascii(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
isascii() (is ASCII) überprüft, ob das Zeichen c ein ASCII- Zeichen ist
(0-127).
Um das Zeichen in ein Standard-ASCII-Zeichen umzuwandeln, kann
das Makro toascii() verwendet werden.
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn das Zeichen ein
Standard- ASCII-Zeichen ist, sonst den Wert 0 (FALSE).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben, überprüft wird 0–177 bzw. 0–200
Beispiel zur Funktion isascii()
#include <stdio.h>
#include <ctype.h>
void main(main)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(isascii(c))
printf("Das Zeichen %c ist ein Standard-ASCII Zeichen \n",c);
else
printf("Das Zeichen %c ist kein Standard-ASCII Zeichen ! \n",c);
}
162
KAPITEL 4. FUNKTIONEN
4.81
isatty()
Name
:
isatty — Gerätetyp überprüfen.
Benutzung
:
int isatty(int c);
Prototyp in
:
<ctype.h>
Beschreibung :
isatty() (is atty) überprüft, ob das über handle angegebene Peripheriegerät in eine der folgenden Klasse fällt :
• Terminal
• Konsole
• Drucker
• serielle Schnittstelle
Return-Wert: :
Arbeitet das Gerät zeichenorientiert, wird ein Wert ungleich 0 =
(TRUE), sonst der Wert 0 (FALSE) zurückgegeben.
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : Headerfile ist <stdlib.h>;
liefert 1, wenn c ein Terminal bezeichnet, sonst 0.
Beispiel zur Funktion isatty()
#include <stdio.h>
#include <io.h>
int main(void)
{
int handle;
/* liefert den Handle der Standard- Druckerschnittstelle (PRN:) */
handle = fileno(stdprn);
if (isatty(handle))
printf("PRN: arbeitet zeichenorientiert\n");
else
printf("PRN: arbeitet nicht zeichenorientiert\\n");
return 0;
}
4.82. ISCNTRL()
4.82
163
iscntrl()
Name
:
iscntrl — Überprüfung Steuerzeichen.
Benutzung
:
int iscntrl(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
iscntrl() (is control) überprüft, ob das Zeichen c ein Steuerzeichen ist.
Berücksichtigt werden die Codes im ASC-Zeichensatzt 0-31 und 127
(DELETE).
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn das Zeichen ein
Steuerzeichen ist, sonst den Wert 0 (FALSE).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion iscntrl()
#include <stdio.h>
#include <ctype.h>
void main(void)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(iscntrl(c))
printf("Das Zeichen ist ein Steuerzeichen \n");
else
printf("Das Zeichen ist kein Steuerzeichen ! \n");
}
164
4.83
KAPITEL 4. FUNKTIONEN
isdigit()
Name
:
isdigit — Überprüfung Ziffer.
Benutzung
:
int isdigit(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
isdigit() (is digit) überprüft, ob das Zeichen c eine Ziffer ist, im Bereich
von :
0 ...9
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn das Zeichen eine
Ziffer ist, sonst den Wert 0 (FALSE).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion isdigit()
#include <stdio.h>
#include <ctype.h>
void main(main)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(isdigit(c))
printf("Das Zeichen %c ist eine Ziffer \n",c);
else
printf("Das Zeichen %c ist keine Ziffer ! \n",c);
}
4.84. ISGRAPH()
4.84
165
isgraph()
Name
:
isgraph — Überprüfung graphisches Zeichen.
Benutzung
:
int isgraph(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
isgraph() (is graphical) überprüft, ob das Zeichen c ein graphisches
Zeichen ist.
Berücksichtigt werden die Codes im ASC-Zeichensatzt von 33-126. Das
Leerzeichen ist kein graphisches, aber ein druckbares Zeichen.
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn es ein grahisches Zeichen ist, sonst den Wert 0 (FALSE).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion isgraph()
#include <stdio.h>
#include <ctype.h>
void main(void)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(isgraph(c))
printf("Das Zeichen %c ist ein graphisches Zeichen \n",c);
else
printf("Das Zeichen %c ist kein graphisches Zeichen ! \n",c);
}
166
4.85
KAPITEL 4. FUNKTIONEN
islower()
Name
:
islower — Überprüfung Kleinbuchstabe.
Benutzung
:
int islower(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
islower() (is lower) überprüft, ob das Zeichen c ein Kleinbuchstabe (a
. . . z) ist.
Berücksichtigt werden die Codes im ASC-Zeichensatzt von 0-127, ohne
die deutsche Umlaute und ß.
Das Makro tolower() kann verwendet werden, um einen Großbuchstaben in einen Kleinbuchstaben umzuwandeln.
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn das Zeichen ein
Kleinbuchstabe ist, sonst den Wert 0 (FALSE).
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion islower()
#include <stdio.h>
#include <ctype.h>
void main(main)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(islower(c))
printf("Das Zeichen %c ist ein Kleinbuchstabe \n",c);
else
printf("Das Zeichen %c ist kein Kleinbuchstabe ! \n",c);
}
4.86. ISPRINT()
4.86
167
isprint()
Name
:
isprint — Überprüfung druckbares Zeichen.
Benutzung
:
int isprint(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
isprint() (is printable) überprüft, ob das Zeichen c ein druckbares Zeichen ist.
Berücksichtigt werden die Codes im ASC-Zeichensatzt von 32-127.
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn das Zeichen
druckbar ist, sonst den Wert 0 (FALSE).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion isprint()
#include <stdio.h>
#include <ctype.h>
void main(void)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(isprint(c))
printf("Das Zeichen %c ist druckbar \n",c);
else
printf("Das Zeichen %c ist nicht druckbar ! \n",c);
}
168
4.87
KAPITEL 4. FUNKTIONEN
ispunct()
Name
:
ispunct — Überprüfung Interpunktionszeichen.
Benutzung
:
int ispunct(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
ispunct() (is punct) überprüft, ob das Zeichen c ein InterpunktionsZeichen ist.
Berücksichtigt werden die Codes im ASCII–Zeichensatz von 33-126, also :
33 . . . 47, 58 . . . 64, 91 . . . 96, 123 . . . 126
Das sind alle graphischen Zeichen ohne Ziffern und Buchstaben.
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn es ein Interpunktionszeichen ist, sonst den Wert 0 (FALSE).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion ispunct()
#include <stdio.h>
#include <ctype.h>
void main(void)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(ispunct(c))
printf("Das Zeichen %c ist ein Interpunktionszeichen \n",c);
else
printf("Das Zeichen %c ist kein Interpunktionszeichen ! \n",c);
}
4.88. ISSPACE()
4.88
169
isspace()
Name
:
isspace — Überprüfung Zwischenraum.
Benutzung
:
int isspace(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
isspace() (is space) überprüft, ob das Zeichen c ein ZwischenraumZeichen ist, d.h. ein horizontales oder vertikales Tabulatorzeichen, ein
Zeichen für Zeilen-/Seitenvorschub, CR-Zeichen oder ein blank ist.
Berücksichtigt werden die Codes im ASCII–Zeichensatz zwischen 9-13
und 32.
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn es ein Zwischenraumzeichen ist, sonst den Wert 0 (FALSE).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion isspace()
#include <stdio.h>
#include <ctype.h>
void main(void)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(isspace(c))
printf("Das Zeichen %c ist ein Zwischenraumzeichen \n",c);
else
printf("Das Zeichen %c ist kein Zwischenraumzeichen ! \n",c);
}
170
4.89
KAPITEL 4. FUNKTIONEN
isupper()
Name
:
isupper — Überprüfung Großbuchstabe.
Benutzung
:
int isupper(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
isupper() (is upper) überprüft, ob das Zeichen c ein Großbuchstabe ist.
Berücksichtigt werden die Codes im ASCII–Zeichensatz von 0-127, ohne deutsche Umlaute.
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn das Zeichen ein
Großbuchstabe ist, sonst den Wert 0 (FALSE).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion isupper()
#include <stdio.h>
#include <ctype.h>
void main(void)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(isupper(c))
printf("Das Zeichen %c ist ein Grossbuchstabe \n",c);
else
printf("Das Zeichen %c ist kein Grossbuchstabe ! \n",c);
}
4.90. ISXDIGIT()
4.90
171
isxdigit()
Name
:
isxdigit — Überprüfung Hexadezimal.
Benutzung
:
int isxdigit(int c);
Prototyp in
:
<ctype.h>
Beschreibung :
(ANSI)
isxdigit() (is hexadecimal digit) überprüft, ob das Zeichen c eine
Hexadezimal- Ziffer ist.
Berücksichtigt werden :
0 . . . 9, A . . . F, a . . . f.
Return-Wert: :
Das Makro liefert einen Wert ungleich 0 (TRUE), wenn das Zeichen eine
Hexadezimalziffer ist, sonst den Wert 0 (FALSE).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion isxdigit()
#include <stdio.h>
#include <ctype.h>
void main(void)
{
int c;
printf("Geben Sie einen ASC-Code (0-255) ein \n");
c=getchar();
if(isxdigit(c))
printf("Das Zeichen %c ist eine Hexadezimalziffer \n",c);
else
printf("Das Zeichen %c ist keine Hexadezimalziffer ! \n",c);
}
172
KAPITEL 4. FUNKTIONEN
4.91
itoa()
Name
:
itoa — konvertiert einen Integer-Wert in einen String.
Benutzung
:
char *itoa(int i, char *string, int basis);
Prototyp in
:
<stdlib.h>
Beschreibung :
itoa() (itoa) konvertiert einen Integer-Wert in einen String um, welcher
mit dem \0-Zeichen abgeschlossen wird, und schreibt diesen in die Variable string. Die Variable basis gibt die Basis des Zahlensystems an
und muß im Bereich von 0 . . . 36 liegen.
Ist die Basis basis=10 und i < 0, wird dem Ergebnis ein Minuszeichen
vorangestellt.
Return-Wert: :
Die Funktion liefert einen Zeiger auf string zurück.
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion itoa()
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
int number = 12345;
char string[25];
itoa(number, string, 10);
printf("Integer = %d\n"
"String = %s\n",
number, string);
return 0;
}
4.92. KBHIT()
4.92
173
kbhit()
Name
:
kbhit — überprüft Tastatureingabe.
Benutzung
:
int kbhit(void);
Prototyp in
:
<conio.h>
Beschreibung :
kbhit() (kbhit) überprüft, ob ein Zeichen über die Tastatur eingegeben
wurde. Die Zeichen können mit getch() oder getche gelesen werden.
Return-Wert: :
Wenn ein Zeichen gelesen wurde, liefert die Funktion kbhit den Wert
0, sonst einen Wert ungleich 0.
Querverweis
:
getch getche
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion kbhit()
#include <conio.h>
int main(void)
{
cprintf("Druecken Sie eine beliebige "
"Taste!");
/* wartet auf den Tastendruck */
while (!kbhit());
cprintf("\r\nTaste gelesen!\r\n");
return 0;
}
174
KAPITEL 4. FUNKTIONEN
4.93
labs()
Name
:
labs — berechnet den Absolutwert eines long-Wertes.
Benutzung
:
long labs(long x);
Prototyp in
:
<stdlib.h, math.h>
(ANSI)
Beschreibung :
labs() (long absolute value) berechnet den Absolutwert eines longWertes.
Für die Berechnung des Absolutwertes einer Zahl vom Typ int oder
double kann die Funktion abs() bzw. fabs() verwendet werden.
Return-Wert: :
Der Absolutwert von x, d.h.
• x, f alls x ≥ 0,
• −x, f alls x < 0
Querverweis
Beispiel
:
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion labs()
#include <stdio.h>
#include <math.h>
int main(void)
{
long result;
long x = -12345678L;
result= labs(x);
printf("Der absolute Betrag von %ld ist %ld\n", x, result);
return 0;
}
4.94. LDEXP()
4.94
175
ldexp()
Name
:
ldexp — berechnet x ∗ 2exp .
Benutzung
:
double ldexp(double m, int exp);
Prototyp in
:
<math.h>
Beschreibung :
ldexp() (ldexp) berechnet den Wert
x ∗ 2exp .
Return-Wert: :
Die Funktion liefert den Wert für
x ∗ 2exp
zurück.
Querverweis
Beispiel
:
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion ldexp()
#include <stdio.h>
#include <math.h>
int main(void)
{
double e = 3,
x = 5;
/* berechnet (2 ** 3) * 5 */
printf("2 hoch %lf mal %lf ist %lf\n",
e, x, ldexp(x,e));
return 0;
}
(ANSI)
176
4.95
KAPITEL 4. FUNKTIONEN
ldiv()
Name
:
ldiv — führt eine long-Division durch.
Benutzung
:
ldiv t ldiv(long x, long y);
Prototyp in
:
<stdlib.h>
Beschreibung :
(ANSI)
ldiv() (long divide) dividiert x durch y.
Der ganzahlige Anteil des Ergebnisses und der Divisonsrest wird in einer Struktur vom Typ ldiv t abgelegt. Dieser Strukturtyp ist in stdlib.h
wie folgt definiert :
typedef
struct
{
long int quot; /* Quotient */
long int rem; /* Divisionsrest */
} ldiv t;
Return-Wert: :
Es wird eine Struktur des beschriebenen Datentyps zurückgeliefert.
Querverweis
:
div
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion ldiv()
#include <stdlib.h>
#include <stdio.h>
ldiv_t lx;
int main(void)
{
lx = ldiv(100000L, 30000L);
printf("100000 dividiert durch 30000 = %ld Rest %ld\n", lx.quot, lx.rem);
return 0;
}
4.96. LFIND()
4.96
177
lfind()
Name
:
lfind — lineare Suche im Array.
Benutzung
:
void *lfind(const void *key, const void *base,
size t *num, size t width,
int (*fcmp)(const void *,const void *)) ;
Prototyp in
:
<stdlib.h>
Beschreibung :
lfind() (lfind) durchsucht ein sequentielles angeordenetes Array nach
dem Wert des Schlüsselfeldes key. Die Suche erfolgt dabei linear.
lfind() verwendet eine vom Programmierer erstellte Vergleichsroutine
fcmp().
Der Parameter base muß auf das erste Element des Arrays zeigen, num
auf einen Integer, der die Anzahl der Array-Elemente enthält. width
gibt die Größe des einzelnen Elements in Bytes an.
Return-Wert: :
lfind() liefert einen Zeiger auf das erste Element des Arrays zurück,
das mit dem gesuchten Schlüsselwort identisch ist. Falls der gesuchte
Eintrag nicht vorhanden ist, wird der Wert NULL zurückgeliefert.
Die Vergleichsroutine muß für:
*elem1 == *elem2
den Wert NULL liefern, andernfalls einen Wert ungleich NULL.
Querverweis
Beispiel
:
:
bsearch lsearch qsort
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : Headerdatei ist <search.h>, sonst wie oben.
178
Beispiel zur Funktion lfind()
/* lfind-Beispiel */
#pragma warn -rpt
#include <stdio.h>
#include <stdlib.h>
typedef (*fcmp)(const void *, const void *);
int compare(int *x, int *y)
{
return( *x - *y );
}
int main(void)
{
int array[5] = {35, 87, 46, 99, 12};
int key;
unsigned int num = 5;
int *result;
key = 99;
result = (int *) lfind(&key, array, &num,
sizeof(int), (fcmp) compare);
if (result)
printf("%d gefunden\n",key);
else
printf("%d nicht gefunden\n",key);
return 0;
}
KAPITEL 4. FUNKTIONEN
4.97. LOCALTIME()
4.97
179
localtime()
Name
:
localtime — konvertiert Anzahl von Sekunden in Datum und Uhrzeit.
(ANSI)
Benutzung
:
struct tm *localtime(const time t *sec);
Prototyp in
:
<stdlib.h, math.h>
Beschreibung :
localtime() (local time) wandelt die mit sec angegebene Anzahl von Sekunden, die seit dem 1. Januar 1970, 0 Uhr vergangen sind, in das lokale
Datum mit Uhrzeit um. Es werden dabei die Zeitzonen und die Sommerzeit berücksichtigt.
Die aktuelle Anzahl der Sekunden erhält man durch der Funktion time().
Der Datentyp time t ist in time.h als long definiert.
Die Struktur tm ist wie folgt definiert:
struct
tm
{
int tm
int tm
int tm
int tm
int tm
int tm
int tm
int tm
int tm
sec; /* Sekunden */
min; /* Minuten */
hour; /* Stunden (0..23) */
mday; /* Tag im Monat (1..31) */
mon; /* Monat (0..11) */
year; /* Jahr */
wday; /* Wochentag (0..6) */
yday; /* Tag im Jahr (0..365) */
isdst; /* Sommerzeit */
};
Die Zählung der Wochentage beginnt mit Sonntag (Wert 0). Wenn
tm isdst einen Wert ungleich NULL hat, wird mit Sommerzeit gerechnet.
Return-Wert: :
Die Funktion liefert einen Zeiger auf eine Struktur vom Typ tm, die das
lokale Datum und die Uhrzeit in umgewandelter Form enthält.
Querverweis
:
Beispiel
:
asctime ctime ftime gmtime
stime time
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : Headerdatei ist <time.h>, sonst wie oben
180
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion localtime()
#include
#include
#include
#include
<time.h>
<stdio.h>
<time.h>
<dos.h>
/* Mitteleuropaeische Zeit & Sommerzeit */
char *tzstr = "TZ=MEZ-1MES";
int main(void)
{
time_t t;
struct tm *area;
/* schreibt den time zone-String in
die Environment-Tabelle */
putenv(tzstr);
tzset();
t = time(NULL);
area = localtime(&t);
printf("Ortszeit: %s", asctime(area));
return 0;
}
4.98. LOG()
4.98
181
log()
Name
:
log — berechnet den natürlichen Logarithmus.
#include
Benutzung
:
:
<math.h>
double log(double x); (real)
complex log(complex x); (komplex)
Prototyp in
:
<math.h,complex.h>
(ANSI)
Beschreibung :
log() (logarithm) berechnet den natürlichen Logarithmus von x nach
der Gleichung :
x = en
und ist die Umkehrfunktion von exp.
Die Funktion ist nur für positive Werte von x definiert.
Der komplexe natürliche Logarithmus wird nach der Gleichung:
log(x) = log(abs(x)) + i ∗ arg(x))
berechnet.
Return-Wert: :
Die Funktion liefert den natürlichen Algorithmus des Argumentes
zurück.
Ist das Argument negativ, so wird HUGE VAL zurückgegeben und die
Fehlervariable errno erhält den Wert EDOM (=domain error).
Ist das Argument 0, so wird HUGE VAL zurückgegeben und die Fehlervariable errno erhält den Wert ERANGE (=range error).
Querverweis
:
complex exp log10 sqrt
Beispiel
:
printf(“log(0.5) = %7.4f\n“,log(0.5));
printf(“log(1.0) = %7.4f\n“,log(1.0));
printf(“log(3.0) = %7.4f\n“,log(3.0));
Ergebnis
:
log(0.5) = -0.6931
log(1.0) = 0.0000
log(3.0) = 1.0986
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
182
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion log()
#include <math.h>
#include <stdio.h>
int main(void)
{
double x = 8.6872;
printf("Der natuerliche Logarithmus von "
"%lf ist %lf\n", x, log(x));
return 0;
}
4.99. LOG10()
4.99
183
log10()
Name
:
log10 — berechnet den Logarithmus zur Basis 10.
#include
Benutzung
:
:
<math.h>
double log10(double x); (real)
complex log10(complex x); (komplex)
Prototyp in
:
<math.h,complex.h>
(ANSI)
Beschreibung :
log10() (logarithm) berechnet den Logarithmus von x nach der Gleichung :
x = 10n .
Die Funktion ist nur für positive Werte von x definiert.
Der komplexe Logarithmus zur Basis 10 wird nach der Gleichung:
log10(x) = log10(x) /log(10)
berechnet.
Return-Wert: :
Die Funktion liefert den Logarithmus zur Basis 10 zurück.
Ist das Argument negativ, so wird HUGE VAL zurückgegeben und die
Fehlervariable errno erhält den Wert EDOM (=domain error).
Ist das Argument 0, so wird HUGE VAL zurückgegeben und die Fehlervariable errno erhält den Wert ERANGE (=range error).
Querverweis
Beispiel
:
:
complex exp log
printf(“log10(0.1) = %4.1f\n“,log10(0.1));
printf(“log10(1.0) = %4.1f\n“,log10(1.0));
printf(“log10(10.0) = %4.1f\n“,log10(10.0));
Ergebnis
:
log10(0.1) = -1.0
log10(1.0) = 0.0
log10(10.0) = 1.0
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion log10()
#include <math.h>
#include <stdio.h>
int main(void)
{
double x = 800.6872;
printf("Der dekadische Logarithmus von "
"%lf ist %lf\n", x, log10(x));
return 0;
}
184
4.100
KAPITEL 4. FUNKTIONEN
longjmp()
Name
:
longjmp — führt Rücksprung zum gespeicherten Umgebungszustand
durch.
(ANSI)
#include
Benutzung
:
:
<setjmp.h>
void longjmp(jmp buf env, int retval);
Prototyp in
:
<setjmp.h>
Beschreibung :
longjmp() (long jump) kann einen Sprung nicht zwingenderweise im
lokalen Bereich innerhalb des Programms ausführen. longjmp() verzweigt an die Stelle, wo zuvor setjmp() aufgerufen wurde.
Beim Aufruf von setjmp() wird der momentane Maschinenzustand
(Prozeß bei UNIX) und die Stack-Umgebung in den Puffer env gerettet. Der Datentyp jmp buf ist in setjmp.h() definiert.
Durch den Aufruf der Funktion longjmp() wird der alte Zustand wiederhergestellt und die Programmausführung unmittelbar nach dem
Aufruf von setjmp fortgesetzt.
Das Programm kann anhand des Return-Wertes von setjmp() entscheiden, ob an dieser Stelle setjmp() aufgerufen oder über longjmp()
zurückverzweigt wurde:
setjmp() liefert den Return-Wert 0; dieser Wert wird beim Rücksprung
mit longjmp() auf einen Wert ! = 0 gesetzt, mittels Variable retval.
Dieser muß daher von 0 verschieden sein, z.B. auf 1 gesetzt sein.
Die Funktionen setjmp() und longjmp() werden typischerweise zur
Fehlerbehandlung eingesetzt.
Hinweis : Vorsicht bei Overlay-Anwendungen !
Nicht in normalen Anwenderprogrammen !
Return-Wert: :
Keiner
Querverweis
:
ctrlbrk setjmp signal
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.100. LONGJMP()
Beispiel zur Funktion longjmp()
#include <stdio.h>
#include <setjmp.h>
#include <process.h>
jmp_buf jumper;
void subroutine(void);
int main(void)
{
int value;
/* value erhaelt von setjmp den Wert 0 */
value = setjmp(jumper);
/* longjmp nimmt das Programm an dieser
Stelle wieder auf und weist value einen
Wert != 0 zu */
if (value != 0)
{
printf("Longjmp() lieferte den Wert "
"%d\n", value);
exit (value);
}
printf("Es folgt der Aufruf von "
"subroutine() ... \n");
subroutine();
return 0;
}
void subroutine(void)
{
longjmp(jumper,1);
}
185
186
4.101
KAPITEL 4. FUNKTIONEN
lseek()
Name
:
lseek — verschiebt den Schreib-/Lesezeiger.
#include
Benutzung
:
:
<io.h>
long lseek(int fp, long offset, int basis);
Prototyp in
:
<io.h>
Beschreibung :
lseek() (long seek) verschiebt den Seek- Zeiger (Schreib-/Lesezeiger)
mit dem File-Handle fp verbundene Datei um offset Bytes :
basis
0
1
2
Bedeutung
vom Dateianfang
von der aktuellen Position
vom Dateiende
Der Seek-Zeiger darf nicht vor den Dateianfang positioniert werden. Wird der Seek-Zeiger hinter das Datei-Ende positioniert und
anschließend eine Schreiboperation ausgeführt, so entsteht eine Lücke
in der Datei mit undefiniertem Inhalt.
Return-Wert: :
Die Funktion liefert die aktuelle Position (= Wert des Dateizeigers)
zurück.
Bei falschem File-Pointer wird der Wert -1L zurückgeliefert, und die
Fehlervariable errno wird auf EBADF (= bad file number) oder EINVAL (= ivalid argument) gesetzt.
Querverweis
:
filelength fseek ftell getc open
sopen ungetc write
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : Headerdatei ist <unistd.h>,
sonst wie oben.
4.101. LSEEK()
Beispiel zur Funktion lseek()
#include
#include
#include
#include
#include
<sys\stat.h>
<string.h>
<stdio.h>
<fcntl.h>
<io.h>
int main(void)
{
int handle;
char msg[] = "Das ist ein Test!\n";
char ch;
/* erzeugt eine Datei */
handle = open("TEST.$$$",
O_CREAT | O_RDWR,
S_IREAD | S_IWRITE);
/* schreibt einige Daten in die Datei */
write(handle, msg, strlen(msg));
/* positioniert auf den Anfang der Datei */
lseek(handle, 0L, SEEK_SET);
/* liest bis zum Dateiende Zeichen
aus der Datei */
do
{
read(handle, &ch, 1);
printf("%c", ch);
} while (!eof(handle));
close(handle);
return 0;
}
187
188
KAPITEL 4. FUNKTIONEN
4.102
malloc()
Name
:
malloc — reserviert Speicherplatz.
#include
Benutzung
:
:
<stdlib.h>
void *malloc (size t size);
Prototyp in
:
<alloc.h,stdlib.h>
(ANSI)
Beschreibung :
malloc() (memory allocation) reserviert einen zusammenhängenden
Speicherplatz von size Bytes. Der Datentyp size t ist in stdlib.h als unsigned int definiert.
Der Block wird nicht initialisiert.
Return-Wert: :
Die Funktion gibt einen Zeiger auf die Anfangsadresse des zugeteilten
Speicherbereiches zurück. Wenn nicht genügend Speicherplatz vorhanden ist oder size den Wert 0 hat, liefert die Funktion den NULL-Zeiger.
Querverweis
:
allocmem calloc free realloc
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : Funktion ist als char *malloc(size) definiert,
Headerdatei ist <malloc.h>
4.102. MALLOC()
Beispiel zur Funktion malloc()
#include
#include
#include
#include
<stdio.h>
<string.h>
<alloc.h>
<process.h>
int main(void)
{
char *str;
/* versucht, Speicher fuer den String zu
reservieren */
if ((str = malloc(10)) == NULL)
{
printf("Nicht genuegend Speicher fuer "
"den String vorhanden\n");
exit(1); /* Ende mit Fehlercode */
}
/* kopiert "Hallo" in den String */
strcpy(str, "Hallo");
/* gibt den String aus */
printf("Das ist der String: %s\n", str);
/* gibt den Speicher fuer den String
wieder frei */
free(str);
return 0;
}
189
190
4.103
KAPITEL 4. FUNKTIONEN
memchr()
Name
:
memchr — sucht Zeichen im String.
#include
Benutzung
:
:
<string.h>
void *memchr(const void *buffer, int c, size t n);
Prototyp in
:
<string.h, mem.h>
(ANSI)
Beschreibung :
memchr() (memory character) sucht in den ersten n Bytes von buffer
des übergebenen Zeichens c.
Der Datentyp size t ist in stdlib.h als unsigned int definiert.
Für das Durchsuchen eines gesamten Strings kann die Funktion strchr()
eingesetzt werden.
Return-Wert: :
Die Funktion gibt einen Zeiger auf die Stelle im Puffer (buffer), wo das
gesuchte Zeichen zum ersten Mal auftritt. Kommt das Zeichen in den
ersten n Bytes im Puffer nicht vor oder es tritt ein Fehler auf, liefert die
Funktion den NULL-Zeiger zurück.
Querverweis
:
strchr
Beispiel
:
s.u.
UNIX
:
Solaris 2.x: wie oben, nur in <memory.h>
SunOS 4.1.x : char *memchr(char *s1, char *s2, int n)
Headerdatei ist <memory.h>
Beispiel zur Funktion memchr()
#include <string.h>
#include <stdio.h>
int main(void)
{
char str[17];
char *ptr;
strcpy(str, "Das ist ein String");
ptr = memchr(str, ’r’, strlen(str));
if (ptr)
printf("Das Zeichen ’r’ befindet sich " "an Position: %d\n",
ptr - str + 1);
else
printf("Zeichen nicht gefunden!\n");
return 0;
}
4.104. MEMCMP()
4.104
191
memcmp()
Name
:
memcmp — vergleicht n Bytes zweier Arrays.
#include
Benutzung
:
:
<mem.h>
int memcmp(const void *buf1, const void *buf2, size t n);
Prototyp in
:
<string.h, mem.h>
(ANSI)
Beschreibung :
memcmp() (memory compare) vergleicht die ersten n Bytes von buf1
mit denen von buf2.
Bei dem ersten nichtübereinstimmenden Zeichen wird der Vergleich
abgebrochen. Der Datentyp size t ist in stdlib.h als unsigned int definiert.
Für den Vergleich von Strings können die Funktionen strcmp() und
strncmp() verwendet werden.
Return-Wert: :
Die Funktion gibt einen int-Wert zurück:
Wert
<0
== 0
>0
Bedeutung
wenn buf1 kleiner als buf2 ist
wenn die Zeichenfolgen identisch sind
wenn buf1 größer als buf2 ist
Querverweis
:
strcmp strncmp
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben, nur in <memory.h>
SunOS 4.1.x : int memcmp(char *s1, char *s2, int n)
Headerdatei ist <memory.h>
192
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion memcmp()
#include <stdio.h>
#include <string.h>
int main(void)
{
char *buf1 = "aaa";
char *buf2 = "bbb";
char *buf3 = "CCC";
int stat;
stat = memcmp(buf1, buf2, strlen(buf1));
if (stat > 0)
printf("buf1 ist groesser als buf2\n");
else
printf("buf1 ist nicht groesser als "
"buf2\n");
stat = memcmp(buf2, buf3, strlen(buf2));
if (stat > 0)
printf("buf2 ist groesser als buf3\n");
else
printf("buf2 ist nicht groesser als "
"buf3\n");
return 0;
}
4.105. MEMCPY()
4.105
193
memcpy()
Name
:
memcpy — kopiert n Bytes aus Quell-Puffer in Ziel-Puffer.
#include
Benutzung
:
:
<mem.h>
void *memcpy(void *dest, const void *src, size t n);
Prototyp in
:
<string.h, mem.h>
(ANSI)
Beschreibung :
memcpy() (memory copy) kopiert n Bytes von Puffer src in den Puffer
dest.
Bei Überlappung von src und dest ist das Verhalten von memcpy undefiniert.
Return-Wert: :
Die Funktion gibt den Zeiger dest zurück.
Querverweis
:
memcmp
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben, nur in <memory.h>
SunOS 4.1.x : char *memcpy(char *s1, char *s2, int n)
Headerdatei ist <memory.h>
Beispiel zur Funktion memcpy()
#include <stdio.h>
#include <string.h>
int main(void)
{
char src[] = "******************************";
char dest[] = "abcdefghijlkmnopqrstuvwxyz0123456789";
char *ptr;
printf("dest vor memcpy: %s\n", dest);
ptr = memcpy(dest, src, strlen(src));
if (ptr)
printf("dest nach memcpy: %s\n", dest);
else
printf("memcpy misslungen\n");
return 0;
}
194
KAPITEL 4. FUNKTIONEN
4.106
memmove()
Name
:
memmove — kopiert einen Block von n Bytes.
#include
Benutzung
:
:
<mem.h>
int *memmove(void *dest, const void *src, size t n);
Prototyp in
:
<string.h, mem.h>
(ANSI)
Beschreibung :
memmove() (memory copy) kopiert n Bytes von Puffer src in den Puffer dest.
Bei Überlappung von src und dest ist sichergestellt, daß Zeichen aus
dem Überlappungsbereich zuerst gelesen und überschrieben werden.
Return-Wert: :
Die Funktion gibt den Zeiger dest zurück.
Querverweis
:
memcpy movmem
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben, nur in <memory>
SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion memmove()
#include <stdio.h>
#include <string.h>
int main(void)
{
char *src = "abcde1234567890";
char *dest;
/* dest und src ueberlappen sich um 5 Bytes */
dest = src + 5;
printf("src vor memmove: %s\n", src);
/* kopiert auch die ueberlappenden 5 Bytes korrekt */
memmove(dest, src, 10);
printf("src nach memmove: %s\n", src);
return 0;
}
4.107. MEMSET()
4.107
memset()
Name
:
memset — setzen von n Bytes des Arrays mit konstantem Wert. (ANSI)
#include
Benutzung
:
:
<mem.h, string.h>
void *memset(void *dest, int c, size t n);
Prototyp in
:
<string.h, mem.h>
Beschreibung :
memset() (memory set) füllt die ersten n Bytes von Puffer dest mit dem
Wert von c auf.
Return-Wert: :
Die Funktion gibt den Zeiger dest zurück.
Querverweis
:
memcpy setmem
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben, nur in <memory.h>
SunOS 4.1.x : char *memset(char *s, int c, int n)
Beispiel zur Funktion memset()
#include <string.h>
#include <stdio.h>
#include <mem.h>
int main(void)
{
char buffer[] = "Hello world\n";
printf("Buffer vor memset: %s\n", buffer);
memset(buffer, ’*’, strlen(buffer) - 1);
printf("Buffer nach memset: %s\n", buffer);
return 0;
}
195
196
4.108
KAPITEL 4. FUNKTIONEN
mktime()
Name
:
mktime — konvertiert die Uhrzeit in das Kalenderformat.
#include
Benutzung
:
:
<time.h>
time t mktime(struct tm *ptr);
Prototyp in
:
<time.h>
Beschreibung :
(ANSI)
mktime() (make time) konvertiert die durch ptr vereinbarten Zeitangaben in die Anzahl von Sekunden, die seit dem 1. Januar 1970, 0 Uhr
vergangen sind.
Die Struktur tm ist wie folgt definiert:
struct tm {
int tm sec;
/* Sekunden */
int tm min;
/* Minuten */
int tm hour;
/* Stunden (0..23) */
int tm mday; /* Tag im Monat (1..31) */
int tm mon;
/* Monat (0..11) */
int tm year;
/* Jahr */
int tm wday; /* Wochentag (0..6) */
int tm yday;
/* Tag im Jahr (0..365) */
int tm isdst;
/* Sommerzeit */
};
Die Komponenten tm wday und tm yday werden von mktime ignoriert und berechnet die Sekunden aus den übrigen Komponenten. Diese
müssen nicht ihren üblichen Wertebereich haben; mktime() konvertiert
die Werte so, daß sie ihren üblichen Wertebereich erhalten.
Return-Wert: :
Die Funktion liefert die Anzahl der Sekunden und im Fehlerfall eine -1.
Querverweis
Beispiel
:
:
localtime time
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : nicht vorhanden
4.108. MKTIME()
Beispiel zur Funktion mktime()
#include <stdio.h>
#include <time.h>
char *wday[] =
{"Sonntag", "Montag", "Dienstag",
"Mittwoch", "Donnerstag", "Freitag",
"Samstag", "unbekannter Tag"
};
int main(void)
{
struct tm time_check;
int year, month, day;
/* Bitte geben Sie ein Datum ein, um den
betreffenden Wochentag zu ermitteln
*/
printf("Geben Sie ein Datum nach dem "
"1.1.1970 ein.\n");
printf("Jahr: ");
scanf("%d", &year);
printf("Monat: ");
scanf("%d", &month);
printf("Tag:
");
scanf("%d", &day);
/* laedt die Struktur mit den eingelesenen Daten */
time_check.tm_year = year - 1900;
time_check.tm_mon = month - 1;
time_check.tm_mday = day;
time_check.tm_hour = 0;
time_check.tm_min = 0;
time_check.tm_sec = 1;
time_check.tm_isdst = -1;
/*
ruft mktime auf, um den Wochentag zu
ermitteln */
if (mktime(&time_check) == -1)
time_check.tm_wday = 7;
/* druckt den Wochentag aus */
printf("Dieser Tag ist ein %s.\n", wday[time_check.tm_wday]);
return 0;
}
197
198
4.109
KAPITEL 4. FUNKTIONEN
modf()
Name
:
modf — zerlegt x in einen gebrochenen und einen ganzahligen Anteil.
(ANSI)
Benutzung
:
double modf(double x, double *inpart);
Prototyp in
:
<math.h>
Beschreibung :
modf() (modulo float) zerlegt den Wert von x in einen gebrochenen
und einen ganzzahligen Anteil.
Der ganzahlige Anteil wird in den von inpart adressierten Speicherbereich geschrieben.
Return-Wert: :
Die Funktion liefert den gebrochenen Anteil von x zurück.
Querverweis
Beispiel
:
:
fmod
double x = 123.456, y, z;
z=modf(x,&y);
printf(“Wert von x: %7.3f \n“,x);
printf(“ganzzahliger Anteil: %7.3f \n“,y);
printf(“gebrochener Anteil: %7.3f \n“,z);
Ergebnis
:
Wert von x : 123.456
ganzzahliger Anteil: 123.000
gebrochener Anteil: 0.456
UNIX
:
Solaris 2.x /SunOS 4.1.x : wie oben
4.109. MODF()
Beispiel zur Funktion modf()
#include <math.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
double fraction, integer;
double number = -100000.567;
fraction = modf(number, &integer);
printf("Der ganzzahlige Anteil von %lf "
"ist %lf,\ndie Nachkommastellen sind %lf\n",
number, integer, fraction);
getch();
return 0;
}
199
200
4.110
KAPITEL 4. FUNKTIONEN
open()
Name
:
open — öffnet eine Datei.
#include
#include
:
:
<fcntl.h>
<sys \stat.h>
Benutzung
:
int open(char *name, int modus [,int permission] );
Prototyp in
:
<io.h>
Beschreibung :
open() (open) eröffnet eine Datei mit dem Dateinamen name zum Lesen und/oder Schreiben oder erzeugt eine neue Datei.
Da die Zugriffsart von den Compilern unterschiedlich behandelt wird,
sollte für modus symbolische Konstanten benutzt werden, die in der
Header-Datei fcntl.h definiert sind. Eine der nachfolgenden Konstanten ist mindestens anzugeben:
modus
O RDONLY
O WDONLY
O RDWR
Bedeutung
nur Lesen
nur Schreiben
Lesen und Schreiben
Die folgenden Konstanten können durch | weiter verknüpft werden:
modus
O APPEND
O CREAT
Bedeutung
Schreiben ab Dateiende
Neue Datei erzeugen und zum Schreiben
eröffnen. Falls die Datei existiert,
hat dieses Flag keine Wirkung.
O TRUNC
Datei zum Schreiben öffnen und auf die
Länge 0 kürzen.
O BINARY Datei im Binärmodus eröffnen (DOS)
O TEXT
Datei im Textmodus eröffnen (DOS)
Wird eine neue Datei mit O CREAT erzeugt, legt permission wie bei
der Funktion creat() die Zugriffsrechte, auch für spätere Öffnungen fest.
Das Argument permission ist optional und wird bei Anwendung von
O CREAT gesetzt. Folgende Parameter sind in sys \stat.h definiert:
permission
S IWRITE
S IREAD
S IREAD | S IWRITE
Bedeutung
nur Schreiben erlaubt
nur Lesen erlaubt
Lesen und Schreiben erlaubt
4.110. OPEN()
Return-Wert: :
201
Die Funktion liefert einen File-Handle zurück, wenn die Datei geöffnet
werden konnte. Im Fehlerfall wird der Wert -1 zurückgegeben und die
Fehlervariable errno enhält dann folgende Werte:
errno
EACESS
EMFILE
ENOENT
EINVACC
Bedeutung
Zugriff nicht erlaubt
Maximalzahl von Dateien bereits offen
Falscher Dateiname oder
Suchweg nicht vorhanden
ungültiger Zugriffscode
Querverweis
:
chmod chsize close creat creatnew createtemp
fdopen filelenght fopen freopen getftime lock
lseek read searchpath write
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben, Headerdatei ist <fcntl.h>
SunOS 4.1.x : wie oben, keine Headerdatei
Beispiel zur Funktion open()
#include
#include
#include
#include
#include
<string.h>
<stdio.h>
<fcntl.h>
<io.h>
<sys\stat.h>
int main(void)
{
int handle;
char msg[] = "Hello world";
if ((handle = open("TEST.$$$",
O_RDWR | O_CREAT | O_TEXT,
S_IREAD | S_IWRITE))== -1)
{
perror("Fehler");
return 1;
}
write(handle, msg, strlen(msg));
close(handle);
return 0;
}
202
KAPITEL 4. FUNKTIONEN
4.111
perror()
Name
:
perror — gibt Systemfehlermeldung aus.
#include
Benutzung
:
:
<stdio.h>
void perror(const char *string);
Prototyp in
:
<stdio.h>
Beschreibung :
(ANSI)
perror() (print error) kann nach einem Fehler aufgerufen werden. perror gibt auf stderr (normalerweise der Bildschirm) zwei Strings aus :
• den vom Programmierer definierten String string;
• danach einen Doppelpunkt, ein Leerzeichen und eine entsprechende Systemfehlermeldung (sys errlist);
• einen Zeilenvorschub
Return-Wert: :
Keiner
Querverweis
:
clearerr eof ferror matherr
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : nicht vorhanden
Beispiel zur Funktion perror()
#include <stdio.h>
int main(void)
{
FILE *fp;
fp = fopen("perror.dat", "r");
if (!fp)
perror("Datei konnte nicht zum Lesen geoeffnet werden");
return 0;
}
4.112. POW()
4.112
203
pow()
Name
:
pow — berechnet die Potenz xy .
#include
Benutzung
:
:
<math.h>
double pow(double x, double y);
Komplexe Version:
#include <complex.h>
complex pow(complex x, double y);
complex pow(double x, complex y);
Prototyp in
:
<math.h> oder <complex.h>
Beschreibung :
(ANSI)
pow() (power) berechnet die Potenz xy .
• Falls x < 0 ist, muß y ganzzahlig sein,
• f alls x = 0 ist, muß y positiv sein.
Return-Wert: :
Die Funktion gibt den Wert xy zurück.
Im Fall eines Über- oder Unterlaufs ist der Return-Wert HUGEVAL
mit einem entsprechenden Vorzeichen versehen, und die Fehlervariable errno erhält den Wert ERANGE (= range error).
Falls die Argumente nicht im zulässigen Definitionsbereich liegen, wird
eine Fehlermeldung auf stderr ausgegeben und der Return-Wert ist 0.
Die Fehlervariable errno erhält den Wert EDOM (= domain error).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion pow()
#include <math.h>
#include <stdio.h>
int main(void)
{
double x = 2.0, y = 3.0;
printf("%lf hoch %lf ist %lf\n", x, y, pow(x, y));
return 0;
}
204
KAPITEL 4. FUNKTIONEN
4.113
printf()
Name
:
printf — gibt formatiert auf dem Bildschirm aus.
#include
Benutzung
:
:
<stdio.h>
int printf(const char *string, . . . , /* arg1 . . . argn */);
Prototyp in
:
<stdio.h>
Beschreibung :
(ANSI)
printf() (print formatted) gibt den Format-String string auf Standardausgabe stdout aus, wobei die darin enthaltenen Formatelemente durch
die Werte aus der Argumentliste arg1, . . . ,argn ersetzt werden.
Ein Formatelement bestimmt, wie ein Argument aus der Argumentliste
interpretiert und ausgegeben wird. Die Reihenfolge der Formatelemente entspricht der Argumentenliste. Dabei muß die Anzahl der Formatangaben mit der Anzahl der Argumente übereinstimmen.
Ein Formatelement hat folgende Form:
% [Flags] [Feldbreite] [.Genauigkeit] typ
Flags
besteht aus einem der Zeichen +, ⊔(blank), − oder
einer Kombination dieser Zeichen. Sie haben folgende Wirkung:
+ - positive Zahlen werden mit einem Vorzeichen ausgegeben,
⊔ - positive Zahlen werden mit einem blank ausgegeben,
- - linksbündige Ausgabe.
Feldbreite
ist einen positive Ganzzahl, welche die Länge eines Ausgabefeldes festlegt. Wenn der Feldbreite ein Minuszeichen vorangestellt ist, wird der
entrechende Argumentwert linksbündig in das Feld gesetzt, andernfalls rechtsbündig. Der verbleibende Platz im Feld wird mit blanks
aufgefüllt. Ist die auszugebende Zeichenfolge länger als das Feld, so
wird sie vollständig ausgegeben, d.h. die Feldbreite wird vergrößert.
4.113. PRINTF()
205
Für die Ausgabe von Zahlen kann der Feldbreite eine 0 vorangestellt
werden. Führende Leerstellen im Ausgabefeld werden dann mit Nullen aufgefüllt.
Als Feldbreite kann auch ein Stern (*) angegeben werden. Dann wird
die Feldbreite durch ein zusätzliches Argument bestimmt, das direkt
vor dem auszugebenden Argument stehen und den Typ int haben muß.
Genauigkeit
legt bei der Ausgabe von Gleitkommazahlen mit den Typangaben f oder
e die Anzahl der Ziffern fest, die hinter dem Dezimalpunkt ausgegeben
werden. Bei der Ausgabe mit g bestimmt sie die Anzahl der signifikanten Stellen. Falls nötig wird gerundet. Ohne Angabe der Genauigkeit
wird der Startwert 6 genommen.
Bei Ganzzahlen bestimmt die Genauigkeitsangabe die Mindestzahl von
Ziffern, die auszugeben sind. Besitzt eine Zahl weniger Ziffern, als Genauigkeit festlegt, so werden Nullen vorangestellt. Der Startwert für die
Genaugigkeit ist hier 1.
Ist das Argument ein String, so bestimmt die Genauigkeitsangabe die
Höchstzahl der Zeichen, die vom String ausgegeben werden.
typ legt fest, wie das entsprechende Argument interpretiert und umgewandelt werden soll. Hierbei muß typ mit dem Typ des Arguments
korrespondieren . Folgende Typangaben sind möglich:
typ Argument-Typ Ausgabe
d,i int
dezimal
u
unsigned int
dezimal
o
unsigned int
oktal
x
unsigned int
hexadez. (a,b,c,d,e,f)
X
unsigned int
hexadez. (A,B,C,D,E,F)
f
e,E
g,G
float/double
float/double
float/double
typ
c
s
Argument-Typ
char / int
String
n
int *
p
Zeiger
%
keiner
Gleitkommazahl
Exponentialdarst.
Gleitkommazahl/Exponent.,
was kürzer ist.
Ausgabe
Einzelnes Zeichen
Ausgabe bis \0
(abh. Genauigkeit)
Speichert im entsprechenden
Argument die Anzahl der bis
dahin ausgegebenen Zeichen.
Die im entsprechenden Argument
enthaltene Adresse wird in
hexadezimaler Form ausgegeben.
Das Zeichen % wird
ausgegeben.
206
KAPITEL 4. FUNKTIONEN
Ist ein Argument vom Typ long, so muß den Typangaben d,i,u,o,x,X
der Buchstabe l vorangestellt werden.
Soll ein Argument vom Typ short interpretiert werden, so muß der
Buchstabe h vorangestellt werden.
Ein Argument vom Typ long double wird ausgegeben, indem den Typangaben f,e,E,g oder G ein L vorangestellt wird.
Return-Wert: :
Die Funktion liefert die Anzahl der ausgegebenen Zeichen, im Fehlerfall EOF zurück.
Querverweis
:
cprint ecvt fprintf fread fscanf putc
puts scanf sprintf vfprintf vprintf
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.113. PRINTF()
207
Beispiel zur Funktion printf()
#include <stdio.h>
#include <string.h>
#define I 555
#define R 5.5
int main(void)
{
int i,j,k,l;
char buf[7],*prefix = buf,tp[20];
printf("Praefix 6d
6o
8x
10.2e
"10.2f\n");
strcpy(prefix,"%");
for (i = 0; i < 2; i++)
{
for (j = 0; j < 2; j++)
for (k = 0; k < 2; k++)
for (l = 0; l < 2; l++)
{
if (i==0) strcat(prefix,"-");
if (j==0) strcat(prefix,"+");
if (k==0) strcat(prefix,"#");
if (l==0) strcat(prefix,"0");
printf("%5s |",prefix);
strcpy(tp,prefix);
strcat(tp,"6d |");
printf(tp,I);
strcpy(tp,"");
strcpy(tp,prefix);
strcat(tp,"6o |");
printf(tp,I);
strcpy(tp,"");
strcpy(tp,prefix);
strcat(tp,"8x |");
printf(tp,I);
strcpy(tp,"");
strcpy(tp,prefix);
strcat(tp,"10.2e |");
printf(tp,R);
strcpy(tp,prefix);
strcat(tp,"10.2f |");
printf(tp,R);
printf(" \n");
strcpy(prefix,"%");
}
}
return 0;
}
"
208
KAPITEL 4. FUNKTIONEN
4.114
putc(),putchar()
Name
:
putc,putchar — gibt ein Zeichen aus.
#include
Benutzung
:
:
<stdio.h>
int putc(int c, FILE *fp);
int putchar(int c);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
putc() (put character) schreibt das Zeichen c auf die Datei, die mit dem
File-Pointer fp verbunden ist.
Das Makro putchar() ist identisch mit putc(int c, stdout), schreibt also
ein Zeichen auf die Standardausgabe.
Return-Wert: :
Das ausgegebene Zeichen, im Fehlerfall EOF
Querverweis
:
fprintf fputc fputch fputchar fputs fwrite getc getchar printf putch
putchar putw vprintf
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion putc()
#include <stdio.h>
int main(void)
{
char msg[] = "Hello world\n";
int i = 0;
while (msg[i])
putc(msg[i++], stdout);
return 0;
}
4.115. PUTS()
4.115
209
puts()
Name
:
puts — schreibt Zeichenkette auf Bildschirm.
#include
Benutzung
:
:
<stdio.h>
int puts(const char *string);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
puts() (put string) schreibt den nullterminierten String string auf
stdout und beendet die Ausgabe mit \n.
Die Gegenfunktion zu puts() ist gets.
Return-Wert: :
Die Funktion liefert das letzte ausgegebene Zeichen (\n), im Fehlerfall
wird EOF zurückgegeben.
Querverweis
:
cputs fputs gets printf putchar
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x wie oben
Beispiel zur Funktion puts()
#include <stdio.h>
int main(void)
{
char string[] = "Das ist der String";
puts(string);
puts(string);
return 0;
}
210
4.116
KAPITEL 4. FUNKTIONEN
qsort()
Name
:
qsort — sortiert n-Elemente in auf- und absteigender Reihenfolge. (ANSI)
#include
Benutzung
:
:
<stdlib.h>
void qsort(void *array, size t n, size t size,
int (*compare)());
Prototyp in
:
<stdlib.h>
Beschreibung :
qsort() (quick-sort) sortiert die Elemente eines Arrays nach dem
QuickSort-Algorithmus in auf und absteigender Reihenfolge. Die Elemente können dabei aus beliebigen Datenstrukturen bestehen.
Argumentenliste:
Argument
array
Bedeutung
Zeiger auf das Element 0 des
zu sortierenden Arrays
n
Anzahl der Elemente
size
Größe des Elementes (Byte)
compare() Zeiger auf
die Vergleichsfunktion
Die Vergleichsfunktion muß für die ausfsteigende Sortierung folgenden
Aufbau haben:
*elem1
<
*elem2 Rückgabewert < 0
*elem1 == *elem2 Rückgabewert = 0
*elem1
>
*elem2 Rückgabewert > 0
Die Vergleichsfunktion muß für die absteigende Sortierung folgenden
Aufbau haben:
*elem1
<
*elem2 Rückgabewert > 0
*elem1 == *elem2 Rückgabewert = 0
*elem1
>
*elem2 Rückgabewert < 0
Return-Wert: :
Die Funktion liefert das letzte ausgegebene Zeichen (\n), im Fehlerfall
wird EOF zurückgegeben.
Querverweis
:
cqsort fqsort gets printf putchar
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : qsort(void *array, size t n, size t size,
int(*compar)(const void *, const void *))
SunOS 4.1.x : wie oben
4.116. QSORT()
Beispiel zur Funktion qsort()
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef int (*fcmp) (const void *, const void *);
int sort_function(const char *a, const char *b);
char list[5][4] = { "Bay", "Bar", "Bac",
"Bau", "Bad"
};
int main()
{
int x;
qsort((void *)list, 5, sizeof(list[0]),
(fcmp) sort_function);
for (x = 0; x < 5; x++)
printf("%s\n", list[x]);
return 0;
}
int sort_function(const char *a, const char *b)
{
return( strcmp(a,b) );
}
211
212
4.117
KAPITEL 4. FUNKTIONEN
raise()
Name
:
raise — sendet Softwaresignal.
#include
Benutzung
:
:
<signal.h>
int raise(int sig);
Prototyp in
:
<signal.h>
Beschreibung :
(ANSI)
raise() (raise) sendet das Signal sig zum ausführenden Programm.
Wurde mit der Funktion signal() eine Behandlungsroutine für die Signalnummer sig festgelegt, so wird diese ausgeführt. Ist keine Behandlungsroutine installiert, wird die Standardaktion für den jeweiligen Signaltyp ausgeführt.
Folgende Signaltypen sind in signal.h definiert :
Signal
SIGARBRT
SIGFPE
SIGILL
SIGINT
Bedeutung
Abnormal termination
Bad floating poit operation
Illegal instruction
Control break interrupt
SIGSEGV
SIGTERM
Invalid access to storage
Request for program
termination
Standardaktion
exit(3)
exit(1)
exit(1)
Aufruf des Interrupts
0x23
exit(1)
exit(1)
Return-Wert: :
Die Funktion liefert bei erfolgreicher Funktion den Wert 0, sonst einen
verschiedenen Wert von 0.
Querverweis
:
abort signal
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : nicht vorhanden
4.117. RAISE()
Beispiel zur Funktion raise()
#include <signal.h>
int main()
{
int a, b;
a = 10;
b = 0;
/* Division-durch-Null-Fehler vorbeugen */
if (b == 0)
raise(SIGFPE);
a = a / b;
return 0;
}
213
214
KAPITEL 4. FUNKTIONEN
4.118
rand()
Name
:
rand — liefert eine Zufallszahl.
#include
Benutzung
:
:
<stdlib.h>
int rand();
Prototyp in
:
<stdlib.h>
(ANSI)
Beschreibung :
rand()
(random)
erzeugt
eine
Zufallszahl
zwischen 0 und RAND MAX. Die Konstante ist in stdlib.h definiert
und hat mindestens den Wert 32767 = 215 − 1.
Soll zum Programmstart eine neue Folge von Zufallszahlen erzeugt
werden, muß der Zufallsgenerator mit srand() initialisiert werden.
Return-Wert: :
Die Funktion liefert die erzeugte Zufallszahl zurück.
Querverweis
:
crand random randomize srand
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion rand()
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
int main(void)
{
int i;
time_t timer;
unsigned s;
/* initialisiert den Zufallsgenerator mit der Systemzeit */
s = (unsigned) time(&timer);
srand(s);
printf("\n10 Zufallszahlen zwischen 0 und 99:\n");
for(i=0; i<10; i++)
printf("%d ", rand() % 100);
return 0;
}
4.119. READ()
4.119
215
read()
Name
:
read — liest Daten aus Datei.
#include
Benutzung
:
:
<io.h>
int read(int fd, void *buffer, unsigned n);
Prototyp in
:
<io.h>
Beschreibung :
read() (read) liest n Bytes aus der mit mit dem File-Handle fd verbundenen Datei in den durch buffer angegebenen Speicherbereich.
Wird die Datei im Modus text (DOS) eröffnet, dann entfernt read CRZeichen und interpretiert Ctrl-Z als Dateiende.
Bei Diskettendateien beginnt der Lesevorgang ab der aktuellen Position.
Bei Gerätedateien ist eine Position nicht definiert-es wird direkt vom
Gerät gelesen.
read kann max. 65534 Bytes lesen.
Return-Wert: :
Die Funktion liefert die tatsächlich eingelesenen Bytes als positive Integer zurück, wobei CR, Ctrl-Z nicht mitgezählt werden. Bei dem Versuch, ab Dateiende zu lesen wird der Wert 0 zurückgegeben.
Im Fehlerfall ist der Return-Wert -1 und die Fehlervariable errno erhält
folgende Werte:
errno
EACCES
EBADF
Bedeutung
Zugriff nicht gestattet
ungültiger File-Handle,
Datei nicht offen
Querverweis
:
fgetpos fseek fsetpos
lseek rewind tell
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben, Headerdatei ist <unistd.h>
SunOS 4.1 x : wie oben, Headerdatei ist <unistd.h>
216
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion read()
#include
#include
#include
#include
#include
#include
<stdio.h>
<io.h>
<alloc.h>
<fcntl.h>
<process.h>
<sys\stat.h>
int main(void)
{
void *buf;
int handle, bytes;
buf = malloc(10);
/*
Sucht im aktuellen Directory nach einer Datei
namens TEST.$$$ und versucht, 10 Bytes daraus
zu lesen. Um das Beispiel auszuprobieren,
sollten Sie die Datei TEST.$$$ anlegen.
*/
if ((handle =
open("TEST.$$$", O_RDONLY | O_BINARY,
S_IWRITE | S_IREAD)) == -1)
{
printf("Fehler beim Versuch, die Datei "
"zu oeffnen!\n");
exit(1);
}
if ((bytes = read(handle, buf, 10)) == -1)
{
printf("Leseversuch misslungen.\n");
exit(1);
}
else
{
printf("read: %d Bytes gelesen.\n",
bytes);
}
return 0;
}
4.120. REALLOC()
4.120
realloc()
Name
:
realloc — ändert die Größe des dynamischen Speicherblocks. (ANSI)
#include
Benutzung
:
:
<io.h>
void *realloc(void *ptr, size t n);
Prototyp in
:
<stdlib.h>, <alloc.h>
Beschreibung :
realloc() (reallocate) verändert die Größe des durch ptr adressierten
Speicherblocks, der zuvor mit malloc(), calloc() oder realloc reserviert
wurde.
n ist dabei die neue Länge des Speicherbereiches.
Die Daten bleiben im reservierten Speicherbereich unverändert. Wird
die Länge des Speicherbereichs vergrößert, so wird gegebenenfalls der
gesamte Datenbereich kopiert.
Return-Wert: :
Die Funktion liefert einen typenlosen Zeiger auf den reservierten,
zusammenhängenden Bereich zurück. Im Fehlerfall wird der NULLZeiger zurückgegeben.
Querverweis
:
calloc free malloc
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben, Headerdatei ist <stdlib.h>
SunOS 4.1.x : wie oben, Headerdatei ist <malloc.h>
217
218
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion realloc()
#include <stdio.h>
#include <alloc.h>
#include <string.h>
int main(void)
{
char *str;
/* reserviert Speicher fuer den String */
str = malloc(10);
/* kopiert "Hallo" in den String */
strcpy(str, "Hallo");
printf("Der String \"%s\" ist an Adresse "
"%p gespeichert.\n", str, str);
/* verdoppelt den Speicher fuer den
String */
str = realloc(str, 20);
printf("Der String \"%s\" ist jetzt an "
"Adresse %p gespeichert.\n",
str, str);
/* gibt den Speicher fuer den String
wieder frei */
free(str);
return 0;
}
4.121. REMOVE()
4.121
219
remove()
Name
:
remove — löscht eine Datei.
#include
Benutzung
:
:
<stdio.h>
int remove(const char *filename);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
remove() (remove) bewirkt, daß die Datei unter dem Dateinamen filename nicht mehr angesprochen werden kann. Gelöscht wird die Datei, wenn keine weiteren links mehr bestehen.
filename kann einen vollständigen Suchweg und/oder Laufwerksbezeichner enthalten.
Ein Directory oder eine schreibgeschützte Datei kann mit remove()
nicht gelöscht werden.
Return-Wert: :
Die Funktion liefert den Wert 0 zurück, im Fehlerfall einen von 0 verschiedenen Wert.
Im
Fehlerfall
erhält
errno
folgende
Werte:
errno
Bedeutung
ENOENT no such file or directory
EACCES
permission denied
Querverweis
:
unlink
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1 x : nicht vorhanden
220
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion remove()
#include <stdio.h>
int main(void)
{
char file[80];
/* fragt nach dem Namen der zu loeschenden Datei */
printf("Zu loeschende Datei: ");
gets(file);
/* loescht die Datei */
if (remove(file) == 0)
printf("%s geloescht.\n",file);
else
perror("Fehler bei remove()");
return 0;
}
4.122. RENAME()
4.122
rename()
Name
:
rename — ändert den Namen einer Datei von oldname auf newname.
(ANSI)
#include
Benutzung
:
:
<stdio.h>
int rename(const char *altname, const char *neuname );
Prototyp in
:
<stdio.h>
Beschreibung :
rename() (rename) benennt den Dateinamen altname in den Dateinamen neuname um.
Die Datei altname muß bereits vorhanden sein. Mit dieser Funktion
kann die Eintragung in ein anderes Directory erfolgen, da hiermit kein
Kopiervorgang verbunden ist.
Return-Wert: :
Konnte die Datei umbenannt werden, wird der Wert 0 zurückgegeben.
Im Fehlerfall wird ein Wert verschieden von 0 zurückgegeben. Die Fehlervariable errno erhält EACCES (= permission denied), ENOENT (=
no such file) oder EXDEV (= cross device link).
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : int rename(char *path1, char *path2);
steht in keiner Headerdatei
221
222
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion rename()
#include <stdio.h>
int main(void)
{
char oldname[80], newname[80];
/* fragt nach dem alten und dem neuen
printf("Alter Name: ");
Namen der Datei */
gets(oldname);
printf("Neuer Name: ");
gets(newname);
/* benennt die Datei um */
if (rename(oldname, newname) == 0)
printf("%s in %s umbenannt.\n", oldname, newname);
else
perror("Fehler bei rename()");
return 0;
}
4.123. REWIND()
4.123
rewind()
Name
:
rewind — setzt den Dateizeiger auf den Anfang der Datei.
#include
Benutzung
:
:
<stdio.h>
void rewind(FILE *fp);
Prototyp in
:
<stdio.h>
223
(ANSI)
Beschreibung :
rewind() (rewind) setzt den Seek-Zeiger der mit dem File-Pointer fp
verbundene Datei auf den Dateianfang zurück. Es wird das Dateiende
-Flag sowie die gesetzten Fehlerflags gelöscht.
rewind entpricht der Funktion fseek(fp,0l, 0) ohne Return-Wert.
fseek() löscht die Fehlerflags nicht.
Return-Wert: :
Keiner
Querverweis
:
fopen fseek ftell
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
224
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion rewind()
#include <stdio.h>
#include <dir.h>
int main(void)
{
FILE *fp;
char *fname = "TXXXXXX", *newname, first;
/* erzeugt eine neue Datei fuer lesenden und
schreibenden Zugriff */
newname = mktemp(fname);
fp = fopen(newname,"w+");
/* schreibt einige Daten in die Datei */
fprintf(fp,"abcdefghijklmnopqrstuvwxyz");
/* positioniert auf den Dateianfang */
rewind(fp);
/* liest ein Zeichen und gibt es aus */
fscanf(fp,"%c",&first);
printf("Das erste Zeichen ist: %c\n",first);
/* schliesst die Datei und loescht sie
wieder */
fclose(fp);
remove(newname);
return 0;
}
4.124. SCANF()
4.124
225
scanf()
Name
:
scanf — liest formatierte Daten ein.
#include
Benutzung
:
:
<stdio.h>
int scanf(const char *formatstring, . . . , /* arg1 . . . argn */);
Prototyp in
:
<stdio.h>
Beschreibung :
(ANSI)
scanf() (scan formatted) liest Zeichen in formatierter Form von der
Standardeingabe und speichert die konvertierten Werte in Variablen,
die durch die Argumente arg1, . . . argn adressiert werden.
scanf() ist die Gegenfunktion zu printf().
Die Interpretation der einzelnen Zeichen erfolgt durch den FormatString formatstring, der Formatelemente enthält. Für jedes Element
muß ein Argument angegeben werden. Überzählige Argumente werden ignoriert.
Ein Formatelement hat folgende allgemeine Form:
%[Feldbreite] typ
Für jedes Formatelement wird das nächste Eingabefeld gelesen, konvertiert und in die entsprechende Variable abgelegt. Eingabefelder
sind durch Zwischenraumzeichen (Leer-, Tabulator- und NewlineZeichen) voneinander getrennt.
Der * unterdrückt eine Zuweisung des korrespondierenden Parameters.
Die Feldbreite legt die max. Zeichenzahl fest, aus der das Eingabefeld
besteht.
typ entspricht den Typangaben bei printf() mit folgenden Möglichkeiten :
226
KAPITEL 4. FUNKTIONEN
typ
d
u
o
x
i
e,f,g
E,F,G
c
s,[]
Eingabe
dezimale Ganzzahl
positive dezimale Ganzzahl
oktale Ganzzahl
hexadezimale Ganzzahl
dezimale, oktale oder
hexadezimale
Argument
int-Zeiger
unsigned-Zeiger
unsigned-Zeiger
unsigned-Zeiger
int-Zeiger
Gleitpunktzahl im Format
einer Gleitpuntkonstanten
einzelnes Zeichen
String
float-Zeiger
p
n
Zeigerwert, hexadezimal
keine
%
ein %-Zeichen
char-Zeiger
char-Zeiger auf den
Anfang eines charVektors
Zeiger auf void-Zeiger
int-Zeiger. Es wird
die Anzahl der bis
dahin eingelesenen
Zeichen gespeichert.
keines
• Bei %i entscheidet das Präfix wie bei ganzzahligen Konstanten
über den Typ.
• Den Typangaben d,i,o,x,u ist der Buchstabe l bzw. h voranzustellen, wenn das Argument die Adresse einer long- bzw. short- Variablen ist.
• Den Typangaben e,f,g,E,F,G ist der Buchstabe l bzw. L voranzustellen, falls das Argument die Adresse einer double- bzw. longdouble Variablen ist.
• %c bewirkt, daß das nächste Zeichen eingelesen wird. Dieses
kann auch ein Zwischenraumzeichen sein. Im Gegensatz dazu
lesen alle anderen Typangaben das nächste Eingabefeld, wobei
führende whitespace-Zeichen (Zwischenraum-Zeichen) überlesen werden. Um whitespace- Zeichen zu überlesen und ein einzelnes Zeichen zu lesen sollte man die Anweisung %1s verwenden.
• %Bc (B=Breite) - scanf() erwartet einen Zeiger auf ein char- Array
mit B Elementen als Adreßparameter.
• %s - es wird ein Zeiger auf ein char Array erwartet. Das Array
Platz muß ein zusätzliches NULL- Zeichen bieten.
4.124. SCANF()
227
• %[Suchmenge] - es wird ein Zeiger auf ein char- Array erwartet (s. %s). Suchmenge ist eine Folge von Zeichen, aus denen die
Eingabe bestehen muß. Für das invertierte Suchen kann das Zeichen ∧ eingesetzt werden.
Beispiele:
%[abc]
Es werden nur die Eingaben der Zeichen
a,b,c erlaubt.
%[∧ abc] Es werden nur die Eingaben der Zeichen
erlaubt, die nicht a,b,c sind.
Das Eingabefeld wird durch ein Zeichen, das nicht zur Suchmenge gehört, beendet. Das whitespace- Zeichen beendet das Eingabefeld nicht.
Bereichsdefinitionen
%[0123456789]
%[0-9]
%[A-Z]
%[A-Za-z]
%[A-Za-zäöüÄÖÜß]
Ziffern 0-9.
Äquivalente Vereinbarung.
Alle Großbuchstaben.
Alle Groß- und Kleinbuchstaben.
Alle Groß- und Kleinbuchstaben,
Umlaute und das ß.
Regeln zur Anwendung
– Das Zeichen vor dem Bindestrich - muß einen ASCII-Code
haben, der mindestens um eins niedriger ist als das auf dem
Bindestrich folgende Zeichen.
– Der Bindestrich darf weder das erste noch das letzte Zeichen der Aufzählung sein.
– Das Zeichen vor und das Zeichen nach dem Bindestrich
muß jeweils den Beginn bzw. das Ende eines Bereichs darstellen, dürfen also nicht gleichzeitig Beginn und Ende
zweier verschiedener Bereiche sein.
Weitere Bedeutung des Bindestrichs
%[-+*/]
%[z-a]
%[+0-9-A-F]
%[+0-9A-F-]
%[∧ -0-9+A-F]
die vier arithmetischen Operatoren.
die Zeichen z,-,a.
das Zeichen +, die Ziffern 0-9,
das Zeichen -, die Buchstaben A-F.
s. vorheriges Beispiel.
sämtliche Zeichen außer -,
den Ziffern 0-9, dem Zeichen +
und Buchstaben A-F.
228
KAPITEL 4. FUNKTIONEN
Ist ein Argument vom Typ long, so muß den Typangaben d,i,u,o,x,X
der Buchstabe l vorangestellt werden.
Soll ein Argument vom Typ short interpretiert werden, so muß der
Buchstabe h vorangestellt werden.
Ein Argument vom Typ long double wird ausgegeben, indem den Typangaben f,e,E,g oder G ein L vorangestellt wird.
Return-Wert: :
Die Funktion liefert die Anzahl der ausgegebenen Zeichen, im Fehlerfall EOF zurück.
Querverweis
:
cprint ecvt fscanf fread fscanf putc
puts scanf sscanf vfscanf vscanf
Beispiel
UNIX
:
:
s.u.
Solaris 2.x / SunOS 4.1.x : wie oben
4.124. SCANF()
Beispiel zur Funktion scanf()
#include <stdio.h>
#include <conio.h>
int main(void)
{
char label[20];
char name[20];
int entries = 0;
int loop, age;
double salary;
struct Entry_struct
{
char name[20];
int
age;
float salary;
} entry[20];
/* Einen bis zu 20 Zeichen langen String
als Label eingeben */
printf("\n\nBitte geben Sie ein Label fuer "
"die Tabelle ein: ");
scanf("%20s", label);
/* falls Falscheingabe Eingabestream
loeschen */
fflush(stdin);
/* Angabe der Anzahl von einzugebenden
Zeichen als Integer */
printf("Wieviele Eintraege werden gemacht? "
"(weniger als 20): ");
scanf("%d", &entries);
fflush(stdin);
/* Eingabe eines Namens auf Gross- und
Kleinbuchstaben beschraenken */
for (loop=0;loop<entries;++loop)
{
printf("\nEingabe %d\n", loop+1);
printf(" Name : ");
scanf("%[A-Za-z]", entry[loop].name);
fflush(stdin);
/* Eingabe einer Altersangabe als
Integer */
printf(" Alter : ");
scanf("%d", &entry[loop].age);
fflush(stdin);
229
230
KAPITEL 4. FUNKTIONEN
/* Eingabe eines Gehalts als
Fliesskommazahl */
printf(" Gehalt : ");
scanf("%f", &entry[loop].salary);
fflush(stdin);
}
/* Eingabe von Name, Alter und Gehalt als
String, Integer und Double */
printf("\nGeben Sie bitte Ihren Namen, Ihr "
"Alter und Ihr Gehalt ein:\n");
scanf("%20s %d %lf", name, &age, &salary);
/* Druckt die Daten, die eingegeben
wurden */
printf("\n\nTabelle: %s.\n",label);
printf("Zusammengestellt von %s, %d Jahre "
"alt; %10.2lf DM schwer:\n",
name, age, salary);
printf("-----------------------------------"
"------------------\n");
for (loop=0;loop<entries;++loop)
printf("%4d | %-20s | %5d | %15.2lf\n",
loop + 1,
entry[loop].name,
entry[loop].age,
entry[loop].salary);
printf("-----------------------------------"
"------------------\n");
return 0;
}
4.125. SETBUF()
231
4.125
setbuf()
Name
:
setbuf — explizite Pufferzuordnung.
#include
Benutzung
:
:
<stdio.h>
void setbuf(FILE *fp, char *buffer);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
setbuf() (set buffer) ordnet dem mit dem File-Handle fd verbundenen Datei den Dateipuffer buffer ein, der die Länge BUFSIZ (defin.
in stdio.h) haben muß.
Falls buffer ein NULL-Zeiger ist, erfolgt die Dateiein-/ausgabe ungepuffert. stdin und stdout arbeiten ungepuffert, wenn sie nicht umgeleitet sind. Umleitungen bewirken in der Regel eine Pufferung, die durch
setbuf verändert werden kann.
Pufferung :
bedeutet, Ausgaben werden zeichenweise zwischengespeichert; Eingaben werden blockweise von der Datei bzw. Gerät gelesen und danach
zeichenweise aus dem Puffer geliefert.
Return-Wert: :
Keiner
Querverweis
:
fflush fopen fseek setvbuf
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
232
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion setbuf()
#include <stdio.h>
/* BUFSIZ wird in stdio.h definiert */
char outbuf[BUFSIZ];
int main(void)
{
int i;
/* ordnet der Standardausgabe einen Puffer zu */
setbuf(stdout, outbuf);
/* schreibt einige Zeichen in den Puffer */
puts("Das ist ein Test fuer gepufferte "
"Ausgabe.\n");
puts("Diese Ausgabe wird in outbuf "
"geschrieben");
puts("und tritt erst dann in Erscheinung,wenn");
puts("der Puffer voll oder der Stream ");
puts("geflusht wird.");
getch();
/* leert Ausgabepuffer */
fflush(stdout);
getch();
return 0;
}
4.126. SETJMP()
233
4.126
setjmp()
Name
:
setjmp — speichert die stack - Umgebung.
#include
Benutzung
:
:
<setjmp.h>
int setjmp(jmp buf env);
Prototyp in
:
<setjmp.h>
(ANSI)
Beschreibung :
setjmp() (set jump) speichert den momentanen Maschinenzustand und
die Stack-Umgebung in den durch env angegebenen Puffer.
Durch einen späteren Aufruf der Funktion longjmp() wird dieser alte
Zustand wiederhergestellt und die Programmausführung hinter dem
Aufruf von setjmp() fortgesetzt, wobei der Return-Wert von setjmp()
verändert wird.
Return-Wert: :
Die Funktion liefert den Wert 0 zurück. Bei einem Rücksprung mit
longjmp() wird dieser auf einen von 0 verschiedenen Wert gesetzt.
Querverweis
:
longjmp signal
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
234
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion setjmp()
#include <stdio.h>
#include <setjmp.h>
#include <process.h>
jmp_buf jumper;
void subroutine(void);
int main(void)
{
int value;
/* value erhaelt von setjmp den Wert 0 */
value = setjmp(jumper);
/* longjmp nimmt das Programm an dieser
Stelle wieder auf und weist value einen
Wert != 0 zu */
if (value != 0)
{
printf("Longjmp() lieferte den Wert "
"%d\n", value);
exit (value);
}
printf("Es folgt der Aufruf von "
"subroutine() ... \n");
subroutine();
return 0;
}
void subroutine(void)
{
longjmp(jumper,1);
}
4.127. SETVBUF()
4.127
235
setvbuf()
Name
:
setvbuf — explizite variable Pufferzuordnung.
#include
Benutzung
:
:
<stdio.h>
int setvbuf(FILE *fp, char *buffer, int mode,
size t size);
Prototyp in
:
<stdio.h>
Beschreibung :
(ANSI)
setvbuf() (set variable buffer) ordnet der mit dem File-Handle fd verbundenen Datei der Länge size anstelle des standardmäßigen Dateipuffer zu. Das Argument mode ist eine der folgenden in stdio.h definierten
Konstanten:
mode
IOFBF
Bedeutung
I/O fully buffered: Ein-und Ausgaben werden
vollständig gepuffert.
IOLBF I/O line buffered : Ausgaben werden zeilenweise
gepuffert, d.h. nach jedem Zeilenvorschub wird
der Pufferinhalt in die Datei geschrieben.
Eingaben werden wie bei IOFBF vollständig
gepuffert.
IONBF I/O not buffered : Ein-und Ausgaben erfolgen
ungepuffert. buffer und size werden
ignoriert.
Falls buffer ein NULL-Zeiger ist, so wird durch einen Aufruf von malloc() ein Puffer der Größe size dynamisch angelegt.
Return-Wert: :
Die Funktion gibt den Wert 0, im Fehlerfall einen von 0 verschiedenen
Wert.
Querverweis
:
fflush fopen setbuf
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
236
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion setvbuf()
#include <stdio.h>
int main(void)
{
FILE *input, *output;
char bufr[512];
input = fopen("Datei.ein", "r+b");
output = fopen("Datei.aus", "w");
/* richtet fuer minimalen Diskettenzugriff einen vollstaendig
gepufferten Eingabestream ein (funktioniert nur, wenn
datei.ein erfolgreich geoeffnet werden konnte) */
printf("Puffer fuer Eingabedatei konnte "
"%sangelegt werden.\n",
setvbuf(input, bufr, _IOFBF, 512) ?
"nicht " : "");
/* Ausgabestream wird zeilenweise gepuffert,
wobei Speicher durch einen indirekten
Aufruf von malloc zugeordnet wird */
printf("Puffer fuer Ausgabedatei konnte "
"%sangelegt werden.\n",
setvbuf(output, NULL, _IOLBF, 132) ?
/* Hier findet die Datei Ein-/Ausgabe statt
...
*/
/* Dateien schliessen */
fclose(input);
fclose(output);
return 0;
}
"nicht " : "");
4.128. SIGNAL()
237
4.128
signal()
Name
:
signal — Signalverarbeitung.
#include
Benutzung
:
:
<signal.h>
void signal(*signal( int sig, void (*func)(int)))(int);
Prototyp in
:
<signal.h>
Beschreibung :
(ANSI)
signal() (signal) ermöglicht die Festlegung, wie ein Programm auf Signale mit der Signalnummer sig reagiert.
Signale werden entweder durch andere Prozesse, von der Tastatur,
durch interne Interrupts, wie z.B. Division durch Null, oder explizit
mit der Funktion raise() erzeugt.
Das Argument func legt die Art der Reaktion fest:
func
SIG DFL
Wirkung beim Eintreffen des Signals sig
signal default.Die Standardroutine für die
Signalnummer wird aufgerufen. Danach wird im
allgemeinen das Programm beendet.
SIG IGN
signal ignore. Das Signal wird ignoriert
und das Programm fortgesetzt.
Adresse einer Zuerst wird signal(sig,SIG DFL) und dann
Funktion
die Funktion (*func)(sig) aufgerufen. Es wird
also für das nächste Signal sig die
Standardroutine eingesetzt und dann die eigentliche
Reaktion auf das momentane Signal ausgeführt.
Soll beim nächsten Signal sig nicht die
Standardroutine ausgeführt werden, so muß wieder
signal() aufgerufen werden, z.B. in der
Funktion (*func)() selbst.
Signal
Bedeutung
SIGABRT abort, abnormale Programmbeendigung, z.B.
durch die Funktion abort() ausgelöst.
Standardmäßig wird das Programm beendet.
SIGFPE
floating point exception, ausgelöst durch
Divisionsfehler, Coprozessor-bzw. Emulator-Fehler.
SIGILL
illegal instruction, ausgelöst durch
ungültigen Maschinenbefehl.
SIGINT
interrupt, ausgelöst durch das Drücken
der Unterbrechungstaste (DOS: Ctrl-C).
SIGSEGV segmentation violation, ausgelöst durch einen
ungültigen Speicherzugriff.
SIGTERM termination, Software-Beendigung des Programms)
(UNIX: Standardsignal des Kill-Kommandos).
238
KAPITEL 4. FUNKTIONEN
Return-Wert: :
Die Funktion liefert bei erfolgreicher Ausführung den Wert von func
aus dem vorhergehenden Aufruf von signal(),also den vorhergehenden Reaktionseintrag.
Beim ersten Aufruf ist das SIG DFL. Trat ein Fehler auf, wird der Fehlercode SIG ERR zurückgegeben und die Fehlervariable errno erhält
den Wert EINVAL.
Querverweis
:
fflush fopen signal
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : void(*signal())();
4.128. SIGNAL()
Beispiel zur Funktion signal() (für DOS)
/* Dieses Beispiel installiert eine SignalHandlerroutine fuer SIGFPE, faengt eine Integerueberlaufbedingung ab, bereinigt das AX-Register
und kehrt zurueck. Je nach verwendetem Speichermodell KOENNTE dieses Beispiel zu einem Systemabsturz fuehren oder Laufzeitfehler erzeugen.
*/
#pragma inline
#include <stdio.h>
#include <signal.h>
void Catcher(int *reglist)
{
printf("Gefasst!\n");
/* liefert 3 in AX zurueck */
*(reglist + 8) = 3;
}
int main(void)
{
signal(SIGFPE, Catcher);
/* AX = 32767 */
asm
mov
ax,07FFFH
/* verursacht einen ueberlauf */
asm
inc
ax
/* aktiviert den Handler */
asm
into
/* Der Handler gab in AX 3 zurueck. Ansonsten
wuerde das naechste into nach der decAnweisung eine weiter Ausnahmebedingung
ausloesen. */
/* kein ueberlauf mehr */
asm
dec
ax
/* Handler wird nicht mehr aktiviert */
asm
into
return 0;
}
239
240
KAPITEL 4. FUNKTIONEN
4.129
sin()
Name
:
#include
:
Benutzung
:
Prototyp in
:
sin — berechnet den Sinus des Argumentes x.
(ANSI)
<math.h> (reel)
<complex.h> (complex)
double sin(double x);
complex sin(complex x);
<math.h> (reel)
<complex.h> (complex)
Beschreibung :
sin() (sine) berechnet den Sinus des Argumentes x.
Der Wert von x wird als Bogenmaß interpretiert. Das Argument x wird
durch Modulodivision in den Bereich 0 bis 2*pi transformiert, wobei
pi = 3.1415927... ist. Ist der Absolutwert des Argumentes sehr groß, so
kann daraus eine zu große Ungenauigkeit für das Ergebnis entstehen.
Return-Wert: :
Die Funktion gibt den Sinus von x im Bogenmaß zurück. Der Wert liegt
im Bereich von -1 und +1.
Im Fehlerfall, wenn der Argumentwert zu groß für ein signifikantes Ergebnis ist, wird der Wert 0 zurückgegeben. Es wird eine Fehlermeldung
auf stderr ausgegeben, und die Fehler- variable errno erhält den Wert
EDOM (= domain error).
Fehlerbehandlung kann ev. unter Verwendung der Funktion matherr
geändert werden.
Querverweis
:
acos asin atan atan2 complex asin
complex sin atan sinh tan
Beispiel
:
double pi = 3.1415927;
printf(“sin(0.0) = %4.1f\n“,sin(0.0));
printf(“sin(pi/2) = %4.1f\n“,sin(pi/2));
printf(“sin(3/2*pi) = %4.1f\n“,sin(3/2*pi));
Ergebnis
:
sin(0.0) = 0.0000
sin(pi/2) = 1.0000
sin(3/2*pi) = -1.0000
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben, aber nur für reele Zahlen
4.129. SIN()
Beispiel zur Funktion sin()
#include <stdio.h>
#include <math.h>
int main(void)
{
printf("Der Sinus von %lf ist %lf\n", 0.5, sin(0.5));
return 0;
}
241
242
4.130
KAPITEL 4. FUNKTIONEN
sinh()
Name
:
#include
:
Benutzung
:
Prototyp in
:
sinh — berechnet den Sinus Hyperbolicus des Argumentes x. (ANSI)
<math.h> (reel)
<complex.h> (complex)
double sinh(double x);
complex sinh(complex x);
<math.h> (reel)
<complex.h> (complex)
Beschreibung :
sinh() (hyperbolic sin) berechnet den Sinus Hyperbolicus des Argumentes x.
Return-Wert: :
Die Funktion gibt den Sinus Hyperbolicus von x im Bogenmaß zurück.
Ist das Ergebnis zu groß, so wird HUGE VAL zurückgegeben und die
Fehlervariable errno erhält den Wert ERANGE (=range error).
Querverweis
:
acos atan2 matherr tan asin complex
sin tanh atan cos cosh
Beispiel
:
printf(“sinh(-5.0) = %8.4f\n“,sinh(-5.0));
printf(“sinh(0.0) = %8.4f\n“,sinh(0.0));
printf(“sinh(5.0) = %8.4f\n“,sinh(5.0));
Ergebnis
:
sinh(-5.0) = -74.2032
sinh(0.0) = 0.0000
sinh(5.0) = 74.2032
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben, aber nur für reele Zahlen
Beispiel zur Funktion sinh()
#include <stdio.h>
#include <math.h>
int main(void)
{
printf("Der Sinus hyperbolicus von %lf ist %lf\n", 0.5, sinh(0.5));
return 0;
}
4.131. SPAWN...()
4.131
spawn...()
Name
:
#include
:
Benutzung
:
Prototyp in
:
Beschreibung :
spawn... — Funktionen zur Erzeugung und Ausführung untergeordneter Prozesse.
<process.h>
<stdio.h>
int spawnl(int mode, char *path, char *arg0,
/* arg1...argn, NULL */);
int spawnle(int mode, char *path, char *arg0,
/* arg1...argn, NULL, char envp[] */);
int spawnlp(int mode, char *path, char *arg0,
/* arg1...argn, NULL */);
int spawnlpe(int mode, char *path, char *arg0,
/* arg1...argn, NULL, char envp[] */);
int spawnv(int mode, char *path, char *argv[]);
int spawnve(int mode, char *path, char *argv[],
char *envp[]);
int spawnvp(int mode, char *path, char *argv[]);
int spawnvpe(int mode, char *path, char *argv[],
char *envp[]);
<process.h>
Die Funktionen spawn...- Familie erzeugen und führen andere Programme aus, die auch untergeordnete Processe genant werden. Es muß
ausreichend Speicherplatz für das Laden und Ausführen dieser Prozesse vorhanden sein.
Das aufrufende Programm (parent) bleibt während der Ausführung
des neu gestarteten Prozesses (child) im Speicher und wird nach dem
Ablauf des untergeordneten Prozesses fortgesetzt.
Der Wert des Parameters mode legt fest, wie sich der übergeordnete Prozeß während der Ausführung des untergeordneten Prozesses
verhält. Die folgenden Konstanten sind in process.h definiert:
P WAIT - Der übergeordnete Prozeß bleibt im Speicher, wird aber für
die Dauer der Ausführung des untergeordneten
Prozesses stillgelegt.
P NOWAIT - Über-und untergeordnete Prozesse werden
konkurrierend ausgeführt.
P OVERLAY - Der übergeordnete Prozeß wird vom untergeordneten
überschrieben und nach dessen Beendigung nicht fortgesetzt (derselbe
Ablauf wie bei exec...).
Hinweis: P NOWAIT ist gegenwärtig nicht verfügbar; die Verwendung
erzeugt einen Fehler.
243
244
KAPITEL 4. FUNKTIONEN
Der Parameter path gibt den Namen des untergeordneten Prozesses an.
Verwendet wird der Standard-Suchalgorithmus von DOS:
Wenn weder eine Namenserweiterung oder ein Punkt angegeben ist,
wird zuerst nach Dateien ohne Erweiterung, dann nach .COM-Dateien
und anschließend nach .EXE-Dateien gesucht.
Wenn eine Namenserweiterung oder ein Punkt angegeben ist, wird
nur nach dem angegebenen Dateinamen gesucht. Bei der Angabe xxx.
sucht DOS nach der Datei XXX, bei der Angabe xxx.yyy nach der Datei
XXX.YYY.
Die p-Varianten von spawn... suchen im aktuellen Verzeichnis, danach
in sämtlichen Verzeichnissen, die durch PATH festgelegt sind. Die Varianten ohne p suchen nur innerhalb des aktuellen Verzeichnisses.
Die einzelnen Funktionen der spawn...-Familie unterscheiden sich
durch die Namensendungen l,v,p und e, wobei jeder dieser Buchstaben für andere Fähigkeiten steht. Es bedeuten:
p PATH - die spawn-Funktion sucht nach dem untergeordneten Prozeß
nicht nur innerhalb des aktuellen Verzeichnisses, sondern auch in sämtlichen durch PATH festgelegten Verzeichnissen.
l LIST - die Kommandozeilenparameter werden an den untergeordneten Prozeß in Form einer Liste einzelner Argumente übergeben, also
als arg0, arg1, ... argn. Die Listenform wird normalerweise verwendet,
wenn die Zahl der Parameter bekannt (und konstant) ist.
v VARIABLE - die Kommandozeilen-Parameter werden an den untergeordneten Prozeß in Form von Zeiger-Arrays übergeben, d.h. als
argv[0], argv[1] ...argv[n]. Diese Form wird normalerweise bei variablen Parameterzahlen verwendet.
4.131. SPAWN...()
e ENVIRONMENT - erlaubt die Übergabe des Zeiger-Array envp (d.h.
eines eigenen Environment für den untergeordneten Prozeß). Ein über
die spawn...-Varianten ohne e aufgerufener untergeordneter Prozeß
verwendet dieselben Umgebungsparameter wie das aufrufende Programm.
Jede Funktion der spawn-Familie enthält entweder ein l oder v im Namen, die weiteren Kombinationen mit p und e sind optional. Zwei Beispiele dazu:
spawnl verwendet eine Liste von Argumenten, sucht nur das aktuelle Verzeichnis nach dem untergeordneten Prozeß ab und übergibt die
Environment-Parameter, die auch für das aktuell laufende Programm
gültig sind.
spawnvpe übergibt die Kommandozeilenparameter als Zeiger-Array,
führt nötigenfalls eine Suche nach dem untergeordneten Prozeß über
die mit PATH gesetzten Suchwege aus und übergibt EnvironmentParameter, die vom Programmierer definiert wurden.
Sämtliche spawn... - Funktionen müssen mindestens ein Argument an
den untergeordneten Prozeß übergeben, nämlich arg0 bzw. arg[0]. Das
erste Argument enthält per Konvention den Pfadnamen des untergeordneten Prozesses. Die Übergabe anderer Daten als erstem Argument
erzeugt jedoch keinen Fehler. Zur Übergabe einer leeren Argumentliste
an den untergeordneten Prozeß muß arg0 bzw. arg[0] NULL sein.
Der path-Wert von arg0 bzw. arg[0] ist nur unter den DOS-Versionen
ab 3.0 für den untergeordneten Prozeß verfügbar. Bei Verwendung der
l-Funktionen zeigt arg0 normalerweise auf denselben String wie path,
arg1,...,argn zeigen auf weitere Strings, die Argumentenliste wird durch
ein (obligatorisches!) NULL beendet.
Die e-Funktionen erwarten ein Zeiger-Array als Argument, dessen Inhalt als *envp[] übergeben wird. Jedes Element dieses Array ist ein nulltermienierter String der Form
envvar = Wert
wobei envvar der Name der Environment-Variablen und Wert der
String-Wert ist, auf den envvar gesetzt wird. Das letzte Element des
Array muß einen Zeiger mit dem Wert NULL enthalten. Dadurch wird
das Listenende gekennzeichnet. Wenn env[0] den Wert NULL hat, verwendet der untergeordnete Prozeß die Environment-Tabelle des übergeordneten Prozesses.
Die Gesamtlänge sämtlicher als arg übergebener Kommandozeilenparameter darf 127 Byte nicht überschreiten (inklusive der automatisch
eingesetzten Leerzeichen zur Trennung einzelner Parameter). Nullzeichen werden bei dieser Zählung nicht berücksichtigt.
spawn... schließt keine Dateien-durch den übergeordneten Prozeß
geöffnete Dateien stehen auch dem untergeordneten Prozeß zur
Verfügung.
245
246
KAPITEL 4. FUNKTIONEN
Return-Wert: :
Die fehlerfreie Ausführung einer spawn...-Funktion hat den Exit-Code
des untergeordneten Prozesses als Rückgabewert. Der Exit-Code eines
Programms kann über exit, exit, abort usw. spezifisch festgelegt werden - normalerweise steht der Wert 0 für erfolgreich ausgeführt. Konnte die spawn...-Funktion dagegen nicht ausgeführt werden, dann wird
-1 zurückgeliefert, und errno bekommt einen der folgenden Werte:
Wert
E2BIG
EINVAL
ENOENT
ENOEXEC
ENOMEM
Bedeutung
Argumentenliste zu lang
Ungültiger Wert für mode
Suchweg/Dateiname nicht gefunden
exec-Formatfehler
Nicht genug Platz im Hauptspeicher
Querverweis
:
abort atexit exit exit exec... fpreset searchpath system
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
4.131. SPAWN...()
Beispiel zur Funktion spawnl()
#include <process.h>
#include <stdio.h>
#include <conio.h>
void spawnl_example(void)
{
int result;
clrscr();
result = spawnl(P_WAIT, "bcc.exe", NULL);
if (result == -1)
{
perror("Error from spawnl");
exit(1);
}
}
void spawnle_example(void)
{
int result;
clrscr();
result = spawnle(P_WAIT, "bcc.exe", NULL, NULL);
if (result == -1)
{
perror("Error from spawnle");
exit(1);
}
}
int main(void)
{
spawnl_example();
spawnle_example();
return 0;
}
247
248
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion spawnlp()
/* spawnlp example */
#include <process.h>
#include <stdio.h>
#include <errno.h>
void main(int argc, char *argv[])
{
int i;
printf("Command line arguments:\n");
for (i=0; i<argc; ++i)
printf("[%2d] : %s\n", i, argv[i]);
printf("About to exec child with arg1 arg2 ...\n");
spawnlp(P_WAIT, "C:\BORLANDC\BIN\BCC.EXE", argv[1], argv[2], NULL);
perror("exec error");
exit(1);
}
Beispiel zur Funktion spawnlpe()
/* spawnlpe example */
#include <process.h>
#include <stdio.h>
#include <errno.h>
int main( int argc, char *argv[], char **envp )
{
int i;
printf("Command line arguments:\n");
for (i=0; i < argc; ++i)
printf("[%2d] %s\n", i, argv[i]);
printf("About to exec child with arg1 arg2 ...\n");
spawnlpe(P_WAIT, "C:\BORLANDC\BIN\BCC.EXE", argv[1], argv[2], NULL, envp);
perror("exec error");
exit(1);
return 0;
}
4.131. SPAWN...()
Beispiel zur Funktion spawnv()
/* spawnv example */
#include <process.h>
#include <stdio.h>
#include <errno.h>
void main(int argc, char *argv[])
{
int i;
printf("Command line arguments:\n");
for (i=0; i<argc; ++i)
printf("[%2d] : %s\n", i, argv[i]);
printf("About to exec child with arg1 arg2 ...\n");
spawnv(P_WAIT,"C:\BORLANDC\BIN\BCC.EXE", argv);
perror("exec error");
exit(1);
}
Beispiel zur Funktion spawnve()
/* spawnve example */
#include <process.h>
#include <stdio.h>
#include <errno.h>
void main(int argc, char *argv[], char **envp)
{
int i;
printf("Command line arguments:\n");
for (i=0; i<argc; ++i)
printf("[%2d] : %s\n", i, argv[i]);
printf("About to exec child with arg1 arg2 ...\n");
spawnve(P_WAIT, "C:\BORLANDC\BIN\TDMEM.EXE", argv, envp);
perror("exec error");
exit(1);
}
249
250
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion spawnvp()
/* spawnvp example */
#include <process.h>
#include <stdio.h>
#include <errno.h>
void main(int argc, char *argv[])
{
int i;
printf("Command line arguments:\n");
for (i=0; i<argc; ++i)
printf("[%2d] : %s\n", i, argv[i]);
printf("About to exec child with arg1 arg2 ...\n");
spawnvp(P_WAIT, "C:\BORLANDC\BIN\BCC.EXE", argv);
perror("exec error");
exit(1);
}
Beispiel zur Funktion spawnvpe()
/* spawnvpe example */
#include <process.h>
#include <stdio.h>
#include <errno.h>
int main( int argc, char *argv[], char **envp )
{
int i;
printf("Command line arguments:\n");
for (i=0; i < argc; ++i)
printf("[%2d] %s\n", i, argv[i]);
printf("About to exec child with arg1 arg2 ...\n");
spawnvpe(P_WAIT, "C:\BORLANDC\BIN\BCC.EXE", argv, envp);
perror("exec error");
exit(1);
return 0;
}
4.132. SPRINTF()
4.132
sprintf()
Name
:
sprintf — formatierte Ausgabe in einen String.
#include
Benutzung
:
:
<stdio.h>
int sprintf(const char *string, const char *formatstring,
. . . /* arg1 . . . argn */);
Prototyp in
:
<stdio.h>
251
(ANSI)
Beschreibung :
sprintf() (string print formatted) kopiert den Format-String formatstring mit den Werten der Argumentliste arg1, . . . argn formatiert in den
String string.
An dem durch string adressierten char-Vektor wird \0 angehängt.
Return-Wert: :
Die Funktion gibt die Anzahl der Zeichen zurück (ohne StringEndezeichen), die in den String kopiert werden.
Querverweis
:
fprintf printf
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion sprintf()
#include <stdio.h>
#include <math.h>
int main(void)
{
char buffer[80];
sprintf(buffer, "%f ist eine Annaeherung "
"von Pi", M_PI);
puts(buffer);
return 0;
}
252
KAPITEL 4. FUNKTIONEN
4.133
sqrt()
Name
:
#include
:
Benutzung
:
Prototyp in
:
sqrt — berechnet die Quadratwurzel des Argumentes x.
(ANSI)
<math.h> (reel)
<complex.h> (complex)
double sqrt(double x);
complex sqrt(complex x);
<math.h> (reel)
<complex.h> (complex)
Beschreibung :
sqrt() (square root) berechnet die Quadratwurzel des Argumentes x.
Der Wert von x darf nicht negativ sein.
Return-Wert: :
Die Funktion gibt den Wert der Quadratwurzel zurück.
Ist das Argument x negativ, wird der Wert 0 zurückgegeben und die
Fehlervariable errno erhält den Wert ERANGE (= range error).
Querverweis
:
complex exp log pow
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben, aber nur für reele Zahlen
Beispiel zur Funktion sqrt()
#include <math.h>
#include <stdio.h>
int main(void)
{
double x = 4.5, result;
result = sqrt(x);
printf("Die Quadratwurzel von %lf ist %lf\n", x, result);
return 0;
}
4.134. SRAND()
253
4.134
srand()
Name
:
srand — initialisiert Zufallsgenerator.
#include
Benutzung
:
:
<stdlib.h>
void srand(unsigned n);
Prototyp in
:
<stdlib.h>
(ANSI)
Beschreibung :
srand() (seed random) initialisiert den Zufallsgenerator mit dem Wert
n.
Mit rand() kann dann eine neue Folge von Zufallszahlen ermittelt werden.
Erfolgt der Aufruf srand(1), so erzeugt rand() dieselbe Folge von Zufallszahlen, die auch ohne Aufruf von srand() enstanden wäre.
Return-Wert: :
Keiner
Querverweis
:
rand random randomize
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : void srand(int n);
254
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion srand()
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
#include <time.h>
int main(void)
{
int i;
unsigned s;
time_t timer;
/* initialisiert den Zufallsgenerator
mit der Systemzeit */
s = (unsigned) time(&timer);
srand(s);
printf("\n10 Zufallszahlen zwischen 0 "
"und 99:\n");
for(i=0; i<10; i++)
printf("%d ", rand() % 100);
/* noch einmal dieselben Zufallszahlen */
srand(s);
printf("\nund noch einmal:\n");
for(i=0; i<10; i++)
printf("%d ", rand() % 100);
return 0;
}
4.135. SSCANF()
255
4.135
sscanf()
Name
:
sscanf — liest eine formatierte Eingabe.
#include
Benutzung
:
:
<stdio.h>
int sscanf(const char *string,
const char *formatstring, . . . /* arg1 . . . argn */);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
sscanf() (string scan formatted) liest und konvertiert Daten aus der Zeichenkette string und schreibt sie in die durch arg1, . . . , argn adressierten Speicherplätze.
Die Funktion ist äquivalent zur Funktion scanf() mit dem Unterschied,
daß anstatt von stdin aus dem durch string adressierten String gelesen
wird.
Return-Wert: :
Die Funktion gibt die Anzahl der tatsächlich übertragenen Eingabefelder zurück.
Bei einem Lesefehler wird der Wert -1 zuückgegeben.
Wird vor der ersten Konvertierung das String-Endezeichen erreicht,
wird EOF zurückgegeben.
Querverweis
:
fscanf scanf
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion sscanf()
#include <stdio.h>
char buffer[] = "a 3.14159 12 zwei Strings\n";
int main(void)
{
char ch;
float f;
int i;
char s1[10], s2[10];
sscanf(buffer, "%c %f %d %s %s",
&ch, &f, &i, s1, s2);
printf("%c %f %d %s %s\n",
ch, f, i, s1, s2);
return 0;
256
}
KAPITEL 4. FUNKTIONEN
4.136. STAT()
4.136
257
stat()
Name
:
stat — ermittelt Status-Informationen einer Datei.
#include
Benutzung
:
:
<sys\stat.h>
int stat(char *file, struct stat *buffer);
Prototyp in
:
<sys\stat.h>
Beschreibung :
stat() (status) ermittelt Status-Informationen der durch file verbundenen Datei und speichert das Ergebnis in durch buffer adressierten
Struktur vom Type stat.
Die Funktion steht auf UNIX, DOS- und OS/2- Maschinen zur
Verfügung und ist auch auf Directories anwendbar.
Die Struktur stat ist wie folgt definiert:
struct
{
};
cat
short
st dev;
unsigned short
unsigned short
short
short
short
short
long
st
st
st
st
st
st
st
long
st atime;
long
st mtime;
long
st ctime;
ino;
mode;
nlink;
uid;
gid;
rdev;
size;
/* Nummer des Laufwerks,
das die Datei enthält */
/* Nur UNIX: I-Knotennummer */
/* Der 16-Bit Dateimodus */
/* Link-Zähler, unter DOS: 1 */
/* Nur UNIX: User-ID */
/* Nur UNIX: Group-ID */
/* Für Gerätedateien */
/* Dateigröße in Bytes,
0 für Gerätedateien */
/* access time- Zeit des
letzten Zugriffs, unter DOS:
st atime = st mtime
/* modification time - Zeit
der letzten Schreiboperation */
/* status change time -Zeit
der letzten Statusänderung
(Lesen ist keine Statusänd. */
258
KAPITEL 4. FUNKTIONEN
Die Komponente st mode enthält mehrere Einzelinformationen, die in
sys\stat.h als Bit-Konstanten vereinbart sind.
Eines der beiden folgenden Bits ist gesetzt:
Bit-Konstante
S IFREG
S IFDIR
Bedeutung
gesetzt, wenn es sich um eine normale
Datei handelt,
gesetzt, wenn file ein Verzeichnis
angibt.
Eines oder beide der folgenden Bits sind gesetzt:
Bit-Konstante
S IWRITE
S IREAD
Bedeutung
gesetzt, wenn die Datei nicht gegen
Schreiben gesperrt ist,
gesetzt, wenn die Datei nicht gegen
Lesen gesperrt ist.
Return-Wert: :
Die Funktion liefert den Wert 0, wenn Statusinformationen ermittelt
werden konnten.
Im Fehlerfall wird -1 zurückgegeben, wobei die Fehlervariable errno
den Wert ENOENT (= no such file or directory) enthält.
Querverweis
:
access chmod fstat
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : int stat(const char *file, struct stat *buf);
SunOS 4.1.x : wie oben
4.136. STAT()
259
Beispiel zur Funktion stat()
#include <sys\stat.h>
#include <stdio.h>
#include <time.h>
#define FILENAME "TEST.$$$"
int main(void)
{
struct stat statbuf;
FILE *stream;
/* oeffnet eine Datei fuer schreibenden Zugriff */
if ((stream = fopen(FILENAME, "w")) == NULL)
{
fprintf(stderr, "Fehler beim Oeffnen der Datei.\n");
return(1);
}
/* schreibt einige Daten in die Datei und schliesst sie wieder */
fprintf(stream, "0123456789");
fclose(stream);
/* ermittelt Informationen ueber die Datei */
stat(FILENAME, &statbuf);
/* zeigt die Informationen an */
if (statbuf.st_mode & S_IFCHR)
printf("Der Name bezeichnet eine logische Geraeteeinheit.\n");
if (statbuf.st_mode & S_IFREG)
printf("Der Name bezeichnet eine gewoehnliche Datei.\n");
if (statbuf.st_mode & S_IREAD)
printf("Der Benutzer hat Leseerlaubnis.\n");
if (statbuf.st_mode & S_IWRITE)
printf("Der Benutzer hat Schreiberlaubnis.\n");
printf("Der Laufwerksbuchstabe ist %c\n",’A’+statbuf.st_dev);
printf("Die Datei ist %ld Bytes gross\n", statbuf.st_size);
printf("Datum der letzten Aenderung: %s", ctime(&statbuf.st_ctime));
return 0;
}
260
KAPITEL 4. FUNKTIONEN
4.137
strcat()
Name
:
strcat — hängt einen String an einen anderen.
#include
Benutzung
:
:
<string.h>
char *strcat(char *s1, const char *s2);
Prototyp in
:
<string.h>
(ANSI)
Beschreibung :
strcat() (string concatenate) hängt die Zeichen von String s2 an das Ende des Strings von s2. Das String-Endezeichen von String s1 wird überschrieben.
Die Länge des Strings s1 muß mindestens
strlen(s1) + strlen(s2) sein.
Soll eine bestimmte Anzahl von Zeichen kopiert werden, ist die Funktion strncat() anzuwenden.
Return-Wert: :
Die Funktion gibt das erste Argument zurück.
Querverweis
:
strncat
Beispiel
:
s.u.
UNIX
:
solaris 2.x : wie oben
SunOS 4.1.x : char *strcat(char *s1, char *s2)
Beispiel zur Funktion strcat()
#include <string.h>
#include <stdio.h>
int main(void)
{
char destination[25];
char *blank = " ", *c = "C++ ist toll!", *turbo = "Turbo";
strcpy(destination, turbo);
strcat(destination, blank);
strcat(destination, c);
printf("%s\n", destination);
return 0;
}
4.138. STRCHR()
4.138
strchr()
Name
:
strchr — sucht ein Zeichen im String.
#include
Benutzung
:
:
<string.h>
char *strchr(const char *s, int c);
Prototyp in
:
<string.h>
261
(ANSI)
Beschreibung :
strchr() (string character) sucht im String s das erste Auftreten des Zeichens c. Das String-Endezeichen \0 gilt als Zeichen des Strings.
Das letzte Auftreten des Zeichens c in s kann mit der Funktion strrchr()
festgestellt werden.
Um ein Zeichen von mehreren Suchzeichen bzw. ein Teilstring zu suchen, kann die Funktion strpbrk() bzw. strstr() verwendet werden.
Return-Wert: :
Die Funktion liefert einen Zeiger auf die Stelle im String s, an der das
Zeichen c zum ersten Mal auftritt. Kommt das Zeichen c im String nicht
vor, wird ein NULL-Zeiger zurückgegeben.
Querverweis
:
strcspn strrchr
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x :char *strchr(char *s, int c);
Beispiel zur Funktion strchr()
#include <string.h>
#include <stdio.h>
int main(void)
{
char string[15];
char *ptr;
int c = ’r’;
strcpy(string, "Das ist ein String");
ptr = strchr(string, c);
if (ptr)
printf("Das Zeichen ’%c’ steht an Position %d\n",
c, ptr-string+1);
else
printf("’%c’ nicht gefunden\n, c");
return 0;
}
262
KAPITEL 4. FUNKTIONEN
4.139
strcmp()
Name
:
strcmp — vergleicht zwei Strings miteinander.
#include
Benutzung
:
:
<string.h>
int strcmp(const char *s1, const char *s2);
Prototyp in
:
<string.h>
(ANSI)
Beschreibung :
strcmp() (string compare) vergleicht String s1 und s2 lexikographisch.
Soll nur eine bestimmte Anzahl von Zeichen eines Strings verglichen
werden, kann die Funktion strncmp() verwendet werden.
Return-Wert: :
Die Funktion liefert folgende Werte zurück:
Return-Wert
< 0
= 0
> 0
Bedeutung
falls s1 < s2,
falls s1 = s2,
falls s1 > s2.
Querverweis
:
strcmpi strcoll stricmp strncmp
strncmpi strnicmp
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : int strcmp(char *s1, char *s2)
4.139. STRCMP()
Beispiel zur Funktion strcmp()
#include <string.h>
#include <stdio.h>
int main(void)
{
char *buf1 = "aaa",
*buf2 = "bbb",
*buf3 = "CCC";
int ptr;
ptr = strcmp(buf2, buf1);
if (ptr > 0)
printf("%s ist groesser als %s\n",
buf2, buf1);
else
printf("%s ist nicht groesser als %s\n",
buf2, buf1);
ptr = strcmp(buf2, buf3);
if (ptr > 0)
printf("%s ist groesser als %s\n",
buf2, buf3);
else
printf("%s ist nicht groesser als %s\n",
buf2, buf3);
return 0;
}
263
264
KAPITEL 4. FUNKTIONEN
4.140
strcpy()
Name
:
strcpy — kopiert einen String in einen anderen.
#include
Benutzung
:
:
<string.h>
char *strcpy(char *s1, const char *s2);
Prototyp in
:
<string.h>
(ANSI)
Beschreibung :
strcpy() (string copy) kopiert den String s2 in den durch s1 adressierten
Speicherbereich.
s1 muß groß genug sein, um das String-Endezeichen mit aufnehmen zu
können.
Sollen maximal n Zeichen kopiert werden, ist die Funktion strncpy() zu
verwenden.
Return-Wert: :
Die Funktion gibt s1 zurück.
Querverweis
:
strncpy
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.2.1 : char *strcpy(char *s1, char *s2);
Beispiel zur Funktion strcpy()
#include <stdio.h>
#include <string.h>
int main(void)
{
char string[10];
char *str1 = "abcdefghi";
strcpy(string, str1);
printf("%s\n", string);
return 0;
}
4.141. STRCSPN()
4.141
strcspn()
Name
:
strcspn — liefert die Länge des Teilstrings von s1, der keines der Zeichen von String s2 enthält.
(ANSI)
#include
Benutzung
:
:
<string.h>
size t *strcspn(const char *s1, const char *s2);
Prototyp in
:
<string.h>
Beschreibung :
strcspn() (string counter set position) liefert die Länge des Teilstrings s
von s1 zurück, der nur aus Zeichen besteht, die in s2 nicht vorkommen.
Das ist die String-Länge von s1 , falls s1 kein Zeichen aus s2 enthält,
oder der Index des ersten Zeichens in s1, das mit einem Zeichen aus s2
übereinstimmt.
Einen Zeiger auf das entsprechende Zeiger liefert die Funktion strpbrk(). Die Länge des Teilstrings, der nur aus Zeichen des Strings s2 besteht, wird von strspn() ermittelt.
Return-Wert: :
Die Funktion liefert die Länge des Teilstrings von s1 zurück, der keines
der Zeichen aus s2 enthält.
Querverweis
:
strchr strrchr strpbrk strspn
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOs 4.1.x : int strcspn(char *s1, char *s2);
Beispiel zur Funktion strcspn()
#include <stdio.h>
#include <string.h>
#include <alloc.h>
int main(void)
{
char *string1 = "1234567890";
char *string2 = "747DC8";
int length;
length = strcspn(string1, string2);
printf("Die ersten %d Zeichen von %s\n"
"enthalten keines der Zeichen aus "
"%s\n", length, string1, string2);
return 0;
265
266
}
KAPITEL 4. FUNKTIONEN
4.142. STRERROR()
4.142
strerror()
Name
:
strerror — liefert einen Zeiger auf einen String mit Fehlermeldungen.
(ANSI)
#include
Benutzung
:
:
<string.h>
char *strerror(int errnum);
Prototyp in
:
<string.h>
Beschreibung :
strerror() (string error) gibt einen Zeiger auf die zur Zahl errnum
gehörige Systemfehlermeldung zurück. Normalerweise ist die Zahl errnum der in der Fehlervariablen errno gespeicherte Wert.
Im Unterschied zur Funktion perror() wird die Fehlermeldung nicht
automatisch auf dem Bildschirm angezeigt. Hierfür muß z.B. die Funktion printf() extra aufgerufen werden.
Return-Wert: :
Die Funktion liefert eine Zeiger auf die Fehlermeldung zurück.
Querverweis
:
perror
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion strerror()
#include <stdio.h>
#include <errno.h>
int main(void)
{
char *buffer;
buffer = strerror(EFAULT);
printf("Fehler: %s\n", buffer);
return 0;
}
267
268
KAPITEL 4. FUNKTIONEN
4.143
strlen()
Name
:
strlen — ermittelt die Länge eines Strings.
#include
Benutzung
:
:
<string.h>
size t strlen(const char *s);
Prototyp in
:
<string.h>
(ANSI)
Beschreibung :
strlen() (string length) bestimmt die Länge des Strings s. Das StringEndezeichen wird nicht berücksichtigt.
Der Datentyp size t ist in string.h als unsigned int definiert.
Return-Wert: :
Die Funktion liefert die Länge des Strings s zurück.
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : int strlen(char *s);
Beispiel zur Funktion strlen()
#include <stdio.h>
#include <string.h>
int main(void)
{
char *string = "C-Kursus";
printf("%d\n", strlen(string));
return 0;
}
4.144. STRNCAT()
4.144
strncat()
Name
:
strncat — hängt einen String bestimmter Länge an einen anderen. (ANSI)
#include
Benutzung
:
:
<string.h>
char *strncat(char *s1, const char *s2, size t n);
Prototyp in
:
<string.h>
Beschreibung :
strncat() (string number concatenate) hängt die ersten n Zeichen des
Strings s2 und \0 an den String s1.
Enthält s2 weniger als n-Zeichen, so wird nur bis zum String-Ende von
s2 kopiert.
Soll der gesamte String s2 angehängt werden, ist die Funktion strcat()
benutzt werden.
Return-Wert: :
Die Funktion liefert s1 zurück.
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : char *strncat(char *s1, char *s2, int n);
Beispiel zur Funktion strncat()
#include <string.h>
#include <stdio.h>
int main(void)
{
char destination[25];
char *blank = " ", *c = "C++ ist toll!", *turbo = "Turbo";
strcpy(destination, turbo);
strcat(destination, blank);
strcat(destination, c);
printf("%s\n", destination);
return 0;
}
269
270
4.145
KAPITEL 4. FUNKTIONEN
strncmp()
Name
:
strncmp — vergleicht eine bestimmte Länge von zwei Strings miteinander.
(ANSI)
#include
Benutzung
:
:
<string.h>
int strncmp(const char *s1, const char *s2, size t n);
Prototyp in
:
<string.h>
Beschreibung :
strncmp() (string number compare) vergleicht die ersten n Zeichen von
String s1 und s2.
Return-Wert: :
Die Funktion liefert die selben Return-Werte wie die Funktion strncmp() unter Berücksichtigung, daß nur n-Zeichen verglichen werden.
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : int strncmp(char *s1, char *s2, int n);
4.145. STRNCMP()
Beispiel zur Funktion strncmp()
#include <string.h>
#include <stdio.h>
int
{
main(void)
char *buf1 = "aaabbb",
*buf2 = "bbbccc",
*buf3 = "ccc";
int ptr;
ptr = strncmp(buf2,buf1,3);
if (ptr > 0)
printf("buf2 ist groesser als buf1\n");
else
printf("buf2 ist kleiner als buf1\n");
ptr = strncmp(buf2,buf3,3);
if (ptr > 0)
printf("buf2 ist groesser als buf3\n");
else
printf("buf2 ist kleiner als buf3\n");
return(0);
}
271
272
KAPITEL 4. FUNKTIONEN
4.146
strncpy()
Name
:
strncpy — kopiert einen String bestimmter Länge in einen anderen.
(ANSI)
#include
Benutzung
:
:
<string.h>
char *strncpy(char *s1, const char *s2, size t n);
Prototyp in
:
<string.h>
Beschreibung :
strncpy() (string number copy) kopiert die ersten n-Zeichen des Strings
s2 in den durch s1 adressierten Speicherbereich.
s1 muß mindestens die Länge n haben, wobei \0 nicht angehängt wird.
Ist die String-Länge von s2 kleiner als n, wird der Rest mit \0 aufgefüllt.
Soll der gesamte String s2 kopiert werden, ist die Funktion strcpy() zu
verwenden.
Return-Wert: :
Die Funktion gibt s1 zurück.
Querverweis
:
strcpy
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : char *strncpy(char *s1, char *s2, int n);
Beispiel zur Funktion strncpy()
#include <stdio.h>
#include <string.h>
int main(void)
{
char string[10];
char *str1 = "abcdefghi";
strncpy(string, str1, 3);
/* an die vierte Position von string muss fuer printf
ein NULL-Zeichen hinzugefuegt werden */
string[3] = ’\0’;
printf("%s\n", string);
return 0;
}
4.147. STRPBRK()
4.147
strpbrk()
Name
:
strpbrk — sucht in einem String nach dem Vorkommen bestimmter
Zeichen ab.
(ANSI)
#include
Benutzung
:
:
<string.h>
char *strpbrk(const char *s1, const char *s2);
Prototyp in
:
<string.h>
Beschreibung :
strpbrk() (string pointer break) sucht den String s1 nach einem der in
s2 enthaltenen Zeichen ab. Das \0-Zeichen wird nicht berücksichtigt.
Ist nur ein Zeichen bzw. Teilstring zu suchen, so kann die die Funktion
strchr() bzw. strstr() verwendet werden.
Return-Wert: :
Die Funktion gibt einen Zeiger auf das erste Zeichen in s1, das mit dem
Zeichen in s2 übereinstimmt, zurück.
Kommt in s1 kein Zeichen aus s2 vor, wird der NULL-Zeiger zurückgegeben.
Querverweis
:
strchr strstr
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : char *strpbrk(char *s1, char *s2);
Beispiel zur Funktion strpbrk()
#include <stdio.h>
#include <string.h>
int main(void)
{
char string[10];
char *str1 = "abcdefghi";
strpbrk(string, str1, 3);
/* an die vierte Position von string muss fuer
printf ein NULL-Zeichen hinzugefuegt werden */
string[3] = ’\0’;
printf("%s\n", string);
return 0;
}
273
274
KAPITEL 4. FUNKTIONEN
4.148
strrchr()
Name
:
strrchr — sucht in einem String nach dem letzten Vorkommen eines
Zeichens.
(ANSI)
#include
Benutzung
:
:
<string.h>
char *strrchr(const char *s, int c);
Prototyp in
:
<string.h>
Beschreibung :
strrchr() (string righ character) sucht im String s das letzte Auftreten
des Zeichens c. Das String-Endezeichen \0 gilt als Zeichen des Strings.
Das erste Auftreten des Zeichens c in s kann mit der Funktion strchr()
festgestellt werden.
Return-Wert: :
Die Funktion liefert einen Zeiger auf die Stelle im String s, an der das
Zeichen c zum letzten Mal auftritt. Kommt das Zeichen c im String nicht
vor, wird ein NULL-Zeiger zurückgegeben.
Querverweis
:
strcspn strchr
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : char *strrchr(char *s, int c);
Beispiel zur Funktion strrchr()
#include <string.h>
#include <stdio.h>
int main(void)
{
char string[15];
char *ptr;
int c = ’i’;
strcpy(string, "Das ist ein String");
ptr = strrchr(string, c);
if (ptr)
printf("strrchr hat ’%c’ an Position %d lokalisiert\n", c, ptr-string+1);
else
printf("’%c’ nicht gefunden\n");
return 0;
}
4.149. STRSPN()
275
4.149
strspn()
Name
:
strspn — liefert die Länge des Teilstrings s1, der nur Zeichen aus der
Zeichenmenge s2 enthält.
(ANSI)
#include
Benutzung
:
:
<string.h>
size t strspn(const char *s1, const char *s2);
Prototyp in
:
<string.h>
Beschreibung :
strspn() (string set position) bestimmt die Länge des Teilstrings von s1,
der nur Zeichen aus der Zeichenmenge von s2 enthält.
Falls s1 nur Zeichen aus s2 enthält, wird die Stringlänge von s1 ermittelt, oder der Index des ersten Zeichens in s1, welches in s2 nicht vorkommt.
Die Länge des Teilstrings, der kein Zeichen des Strings s2 enthält, wird
mit der Funktion strcspn() ermittelt.
Return-Wert: :
Die Funktion gibt die Länge des Teilstrings von s1 zurück, der nur Zeichen aus s2 enthält.
Querverweis
:
strcspn
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : int strcspn(char *s1, char *s2);
Beispiel zur Funktion strspn()
#include <stdio.h>
#include <string.h>
#include <alloc.h>
int main(void)
{
char *string1 = "1234567890";
char *string2 = "2DC813";
int length;
length = strspn(string1, string2);
printf("Das erste Zeichen in %s, das in %s nicht vorkommt,\nsteht an "
"Position %d.\n", string1, string2, length+1);
return 0;
}
276
KAPITEL 4. FUNKTIONEN
4.150
strstr()
Name
:
strstr — sucht im String s1 nach einem Teilstring.
#include
Benutzung
:
:
<string.h>
char *strstr(const char *s1, const char *s2);
Prototyp in
:
<string.h>
(ANSI)
Beschreibung :
strstr() (string in string) sucht im String s1 den Teilstring s2 (ohne
String-Endezeichen \0).
Um ein Zeichen oder eines von mehreren Suchzeichen zu lokalisieren,
kann die Funktion strchr() oder strpbrk() verwendet werden.
Return-Wert: :
Die Funktion liefert einen Zeiger auf den Beginn von s2 in s1 zurück.
Ist s2 in s1 nicht enthalten, wird ein NULL - Zeiger zurückgegeben. Hat
s2 die Länge 0, ist der Return-Wert s1.
Querverweis
:
strchr strpbrk
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : char *strstr(char *s1, char *s2);
Beispiel zur Funktion strstr()
#include <stdio.h>
#include <string.h>
int main(void)
{
char *str1 = "International",
*str2 = "nation",
*ptr;
ptr = strstr(str1, str2);
printf("Das ist der Substring: %s\n", ptr);
return 0;
}
4.151. STRTOD()
4.151
strtod()
Name
:
strtod — konvertiert einen String in einen double-Wert.
#include
Benutzung
:
:
<stdlib.h>
double strtod(const char *s, char **endptr);
Prototyp in
:
<stdlib.h>
277
(ANSI)
Beschreibung :
strtod() (string to double) wandelt einen String s in eine Zahl vom Typ
double um. Bei dem ersten Zeichen, welches nicht als Teil einer Gleitkommazahl interpretiert werden kann, wird die Umwandlung unterbrochen.
Als zweites Argument erwartet die Funktion die Adresse eines charZeigers. Falls dies nicht der NULL- Zeiger ist, wird der durch endptr
adressierte char-Zeiger auf das erste Zeichen von s gesetzt, das nicht
mehr als Teil der Gleitpunktzahl interpretiert werden konnte.
Die umzuwandelnde Zahl muß in der üblichen Gleitkommadarstellung
vorliegen.
Führende Zwischenraumzeichen werden ignoriert.
Return-Wert: :
Die Funktion liefert einen double-Wert zurück.
Im Falle eines Überlaufs wird plus oder minus HUGE VAL zurückgeliefert, bei einem Unterlauf 0. In beiden Fällen erhält die Fehlervariable
errno den Wert ERANGE (= range error).
Querverweis
:
atof
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
sunOS 4.1.x : double strtod(char *str, char **endptr);
278
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion strtod()
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char input[80], *endptr;
double value;
printf("Geben Sie eine Fliesspunktzahl "
"ein: ");
gets(input);
value = strtod(input, &endptr);
printf("Der String %s\nwurde in die Zahl "
"%lf konvertiert.\n", input, value);
return 0;
}
4.152. STRTOK()
279
4.152
strtok()
Name
:
strtok — sucht einen String nach einer von mehreren Zeichenfolgen ab,
die in einem zweiten String definiert sind.
(ANSI)
#include
Benutzung
:
:
<string.h>
char *strtok(const char *s1, const char *s2);
Prototyp in
:
<string.h>
Beschreibung :
strtok() (string token) zerlegt den String s1 in sogenannte Token, die
voneinander in der s2 definierten Zeichenkette getrennt sind.
Enthält s1 den String Hallo C-Freaks ! und s2 die Zeichenkette (blank),
dann sind in s1 drei Token enhalten. Dieses sind: Hallo,C-Freaks und !.
Beim ersten Aufruf bestimmt die Funktion das erste Token in s1 und
hängt ein String-Endezeichen \0 an. Der ursprüngliche String s1 wird
also verändert, indem das erste Trennzeichen nach dem Token durch
das String-Endezeichen \0 überschrieben wird. Bei jedem weiteren Aufruf der Funktion mit NULL anstelle von s1 wird das nächste Token
gesucht und ein String-Endekennzeichen \0 angehängt. Der String s2
kann bei jedem Aufruf der Funktion ausgewechselt werden.
Bei dem ersten Zeichen, welches nicht als Teil einer Gleitkommazahl
interpretiert werden kann, wird die Umwandlung unterbrochen.
Als zweites Argument erwartet die Funktion die Adresse eines charZeigers. Falls dies nicht der NULL- Zeiger ist, wird der durch endptr
adressierte char-Zeiger auf das erste Zeichen von s gesetzt, das nicht
mehr als Teil der Gleitpunktzahl interpretiert werden konnte.
Die umzuwandelnde Zahl muß in der üblichen Gleitkommadarstellung
vorliegen.
Führende Zwischenraumzeichen werden ignoriert.
Return-Wert: :
Die Funktion liefert einen double-Wert zurück.
Im Falle eines Überlaufs wird plus oder minus HUGE VAL zurückgeliefert, bei einem Unterlauf 0. In beiden Fällen erhält die Fehlervariable
errno den Wert ERANGE (= range error).
Querverweis
:
atof
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SubOS 4.1.x : char *strtok(char *s1, char *s2);
280
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion strtok()
#include <string.h>
#include <stdio.h>
int main(void)
{
char input[80] =
"ein, zwei Woerter; ..."
"(usw.)\nSchluss\tjetzt";
char *p;
printf("Das war der String: %s\n",
input);
/* erstes "token" */
p = strtok(input, " ,");
while (p)
{
printf("%s\n", p);
/* folgende "tokens" */
p = strtok(NULL, " ,.;()\t\n");
}
return 0;
}
4.153. STRTOL()
4.153
281
strtol()
Name
:
strtol — konvertiert einen String in einen long-Wert.
#include
Benutzung
:
:
<stdlib.h>
long strtol(const char *s, char **endptr, int base);
Prototyp in
:
<stdlib.h>
Beschreibung :
(ANSI)
strtol() (string to long) wandelt einen String s in eine Zahl vom Typ
long um. Die Zeichenfolge wird gemäß der Basis base umgewandelt,
wobei base im Bereich 2 . . . 36 liegen kann. Bei base = 0 gilt folgende
Konvention:
erstes
Zeichen
0
0
1 bis 9
zweites
Zeichen
1 bis 7
x oder X
String wird
interpretiert als
Oktalzahl
Hexadezimalzahl
Dezimalzahl
Die Umwandlung wird abgebrochen, wenn das Zeichen nicht als Teil
einer Zahl zur Basis base interpretiert werden kann. Dabei werden
führende Zwischenraumzeichen überlesen.
Wurde für den Paramter endptr die Adresse eines Zeigers angegeben,
wird der durch endptr adressierte char-Zeiger auf das erste Zeichen im
String s gesetzt, welches nicht mehr als Teil einer Zahl zur Basis base
interpretiert werden konnte.
Return-Wert: :
Die Funktion liefert einen long-Wert zurück.
Konnte keine Umwandlung durchgeführt werden, wird der Wert
0 zurückgegeben. Im Falle eines Überlaufs ist der Return-Wert
LONG MAX bzw. LONG MIN je nach Vorzeichen und die Fehlervariable errno erhält den Wert ERANGE (= range error).
Querverweis
:
atoi atol stroul
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : long strtol(char *s, char **endptr, int base);
282
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion strtol()
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
char *string = "-0xCafe15", *endptr;
long lnumber;
/* konvertiert den String in einen long-Wert
lnumber = strtol(string, &endptr, 0);
printf("String = %s\nlong
= %ld\n",
string, lnumber);
return 0;
}
*/
4.154. STRTOUL()
4.154
strtoul()
Name
:
283
strtoul — konvertiert einen String in einen unsigned long-Wert. (ANSI)
#include
Benutzung
:
:
<stdlib.h>
double strtoul(const char *s, char **endptr, int base);
Prototyp in
:
<stdlib.h>
Beschreibung :
strtoul() (string to unsigned long) wandelt einen String s in eine Zahl
vom Typ unsigned long um. Die Zeichenfolge wird gemäß der Basis
base umgewandelt, wobei base im Bereich 2 . . . 36 liegen kann. Bei base
= 0 gilt folgende Konvention:
erstes
Zeichen
0
0
1 bis 9
zweites
Zeichen
1 bis 7
x oder X
String wird
interpretiert als
Oktalzahl
Hexadezimalzahl
Dezimalzahl
Die Umwandlung wird abgebrochen, wenn das Zeichen nicht als Teil
einer Zahl zur Basis base interpretiert werden kann. Dabei werden
führende Zwischenraumzeichen überlesen.
Wurde für den Parameter endptr die Adresse eines Zeigers angegeben,
wird der durch endptr adressierte char-Zeiger auf das erste Zeichen im
String s gesetzt, welches nicht mehr als Teil einer Zahl zur Basis base
interpretiert werden konnte.
Return-Wert: :
Die Funktion liefert einen long-Wert zurück.
Konnte keine Umwandlung durchgeführt werden, wird der Wert
0 zurückgegeben. Im Falle eines Überlaufs ist der Return-Wert
LONG MAX bzw. LONG MIN je nach Vorzeichen und die Fehlervariable errno erhält den Wert ERANGE (= range error).
Querverweis
:
atoi atol stroul
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben
SunOS 4.1.x : nicht vorhanden
284
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion strtoul()
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
char *string = "0xCafe15", *endptr;
unsigned long lnumber;
/* konvertiert den String in einen
long-Wert */
lnumber = strtoul(string, &endptr, 0);
printf("String = %s\nu-long = %ld\n",
string, lnumber);
return 0;
}
4.155. SYSTEM()
285
4.155
system()
Name
:
system — Ausführung eines DOS-Befehls.
#include
Benutzung
:
:
<stdlib.h>
int system(const char *s);
Prototyp in
:
<string.h>
(ANSI)
Beschreibung :
system() (system) übergibt den in s angegebenen String an dem
Kommando-Interpreter des Betriebssystems. Der abgesetzte Befehl
wird so ausgeführt, als wäre dieser auf Betriebsystemebene über die
Tastatur abgesetzt worden.
Mit der Übergabe des NULL-Zeiger kann festgestellt werden, ob ein
Kommando-Interpreter verfügbar ist.
Return-Wert: :
Die Funktion liefert einen Wert ungleich Null, falls s ein NULL-Zeiger
und der Kommando-Interpreter verfügbar ist. Ist s kein NULL-Zeiger,
so wird der Wert 0, falls der Kommando-Interpreter erfolgreich gestartet wurde.
Ist das Argument nicht der NULL-Zeiger, so ist der Return-Wert vom
Compiler abhängig. In der Regel wird bei korrekter Ausführung des
Befehls der Wert 0 zurückgegeben. Ein von 0 verschiedener Wert zeigt
einen Fehler an.
Querverweis
:
exec . . . searchpath spawn . . .
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben, Headerdatei ist <stdlib.h>
SunOS 4.1.x : system(char *string);
steht in keinem Headerfile
Beispiel zur Funktion system()
#include <stdlib.h>
#include <stdio.h>
int main(void)
{
printf("Uebergibt an COMMAND.COM und kann "
"auch einen internen DOS-Befehl ausfuehren:\n");
system("dir *.c /p");
return 0;
}
286
4.156
KAPITEL 4. FUNKTIONEN
tan()
Name
:
tan — berechnet den Tangens des Argumentes x.
#include
Benutzung
:
:
<math.h>
double tan(double x);
complex tan(complex x);
Prototyp in
:
<math.h> (reel)
<complex.h> (complex)
(ANSI)
Beschreibung :
tan() (tangent) berechnet den Tangens des Argumentes x.
Der Wert von x wird als Bogenmaß interpretiert. Ist der Absolutwert
des Argumentes sehr groß, so kann daraus eine zu große Ungenauigkeit für das Ergebnis entstehen.
Return-Wert: :
Die Funktion gibt den Tangens von x im Bogenmaß zurück.
Ist der Argumentwert zu groß für ein signifikantes Ergebnis oder liegt x
zu nahe an an dem ganzzahligen Vielfachen von PI/2, den Polstellen der
Tangensfunktion, so wird der Wert 0 zurückgegeben. In beiden Fällen
erhält die Fehler- variable errno den Wert ERANGE (= range error).
Fehlerbehandlung kann ev. unter Verwendung der Funktion matherr
geändert werden.
Querverweis
:
acos asin atan atan2
cos sin
Beispiel
:
printf(“tan(-1.0) = %7.4f\n“,tan(-1.0));
printf(“tan(0.0) = %7.4f\n“,tan(0.0));
printf(“tan(1.0) = %7.4f\n“,tan(1.0));
Ergebnis
:
tan(-1.0) = -1.5574
tan(0.0) = 0.0000
tan(1.0) = 1.5574
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben, nur für reele Zahlen
4.156. TAN()
Beispiel zur Funktion tan()
#include <stdio.h>
#include <math.h>
int main(void)
{
double result, x;
x = 0.5;
result = tan(x);
printf("Der Tangens von %lf ist %lf\n",
x, result);
return 0;
}
287
288
4.157
KAPITEL 4. FUNKTIONEN
tanh()
Name
:
tanh — berechnet den Tangens Hyperbolicus des Argumentes x.
(ANSI)
#include
Benutzung
:
:
<math.h>
double tanh(double x);
complex tanh(complex x);
Prototyp in
:
<math.h> (reel)
<complex.h> (complex)
Beschreibung :
tanh() (hyperbolic tangent) berechnet den Tangens hyperbolicus des
Argumentes x.
Return-Wert: :
Die Funktion liefert den Tangens hyperbolicus von x zurück, der zwischen -1 und +1 liegt.
Ein Fehlerwert wird nicht angezeigt.
Querverweis
:
cos cosh sin sinh tan
Beispiel
:
printf(“tanh(-2.0) = %7.4f\n“,tanh(-2.0));
printf(“tanh(0.0) = %7.4f\n“,tanh(0.0));
printf(“tanh(2.0) = %7.4f\n“,tanh(2.0));
Ergebnis
:
tanh(-2.0) = -.9640
tanh(0.0) = 0.0000
tanh(2.0) = 0.9640
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben, nur für reele Zahlen
Beispiel zur Funktion tanh()
#include <stdio.h>
#include <math.h>
int main(void)
{
double result, x;
x = 0.5;
result = tanh(x);
printf("Der Tangens hyperbolicus von %lf ist %lf\n", x, result);
return 0;
}
4.158. TIME()
4.158
289
time()
Name
:
time — liefert Datum und Uhrzeit des Systems.
#include
Benutzung
:
:
<time.h>
time t time(time t, *ptr);
Prototyp in
:
<time.h>
(ANSI)
Beschreibung :
time() (time) berechnet die Anzahl der Sekunden, die seit dem 1.1.1970,
00:00:00 Uhr (Greenwich Mean Time) vergangen sind. Das Ergebnis
wird sowohl in dem durch ptr adressierten Speicherplatz gespeichert
als auch als Return-Wert zurückgegeben.
Das Argument ptr kann anschließend einer der Funktionen ctime(),
gmtime() oder localtime zur entsprechenden Formatumwandlung
übergeben werden.
Wird der NULL-Zeiger als Argument übergeben, wird das Ergebnis nur
als Return-Wert zurückgegeben. Der Datentyp time t ist in time.h als
long definiert.
Return-Wert: :
Die Funktion liefert die Anzahl der Sekunden, die seit dem 1.1.19070,
00:00:00 Uhr vergangen sind, zurück.
Querverweis
:
asctime localtime timezone
ctime gmtime gettime
Beispiel
UNIX
:
:
s.u.
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion time()
#include <time.h>
#include <stdio.h>
#include <dos.h>
int main(void)
{
time_t t;
t = time(NULL);
printf("%ld Sekunden sind seit dem 1.Januar 1970 vergangen.\n",t);
return 0;
}
290
KAPITEL 4. FUNKTIONEN
4.159
tmpfile()
Name
:
tmpfile — eröffnet eine temporäre Datei im Binär-Modus.
#include
Benutzung
:
:
<stdio.h>
FILE *tmpfile(void);
Prototyp in
:
<stdio.h>
(ANSI)
Beschreibung :
tmpfile() (temporary file) eröffnet eine temporäre Datei im BinärModus zum Schreiben und Lesen (w+b).
Die Datei wird automatisch gelöscht, wenn das Programm endet oder
wenn die Datei vorher geschlossen wird.
Return-Wert: :
Die Funktion liefert einen File-Pointer zurück, wenn die Datei eröffnet
werden konnte, anderfalls einen NULL-Zeiger.
Querverweis
:
fopen tmpnam
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion tmpfile()
#include <stdio.h>
#include <process.h>
int main(void)
{
FILE *tempfp;
tempfp = tmpfile();
if (tempfp)
printf("Temporaere Datei angelegt.\n");
else
{
printf("Konnte temporaere Datei nicht anlegen.\n");
exit(1);
}
return 0;
}
4.160. TMPNAM()
4.160
tmpnam()
Name
:
tmpnam — erzeugt eindeutige Namen für temporäre Dateien. (ANSI)
#include
Benutzung
:
:
<stdio.h>
char *tmpnam(char *s);
Prototyp in
:
<stdio.h>
Beschreibung :
tmpnam() (temporary name) erzeugt einen neuen Dateinamen, der für
eine temporäre Datei verwendet werden kann. Es wird garantiert, daß
der neu Dateiname von allen bereits existierenden im aktuellen Directory verschieden ist,
Falls s ein NULL-Zeiger enthält, wird der erzeugte Dateiname in einem
internen statischen Puffer abgelegt, der bei einem erneuten Aufruf der
Funktion tmpnam() überschrieben wird.
Ist s kein NULL-Zeiger, so erwartet tmpnam(), daß s auf einen charVektor zeigt, der mindestens L tmpnam-Bytes speichern kann. In s
wird der Dateiname kopiert.
Die Funktion kann bis zu TMP MAX verschiedene Dateinamen erstellen. Die symbolischen Konstanten L tmpnam und TMP MAX sind in
stdio.h definiert.
Return-Wert: :
Die Funktion liefert in s einen Dateinamen zurück, wenn s nicht der
NULL-Zeiger ist. Ist s ein NULL-Zeiger, so wird ein Zeiger auf den internen Puffer mit dem neuen Dateinamen geliefert.
Querverweis
:
tmpfile
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
291
292
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion tmpnam()
#include <stdio.h>
#include <process.h>
int main(void)
{
FILE *tempfp;
tempfp = tmpnam();
if (tempfp)
printf("Temporaere Datei angelegt.\n");
else
{
printf("Konnte temporaere Datei nicht anlegen.\n");
exit(1);
}
return 0;
}
4.161. TOASCII()
4.161
toascii()
Name
:
toascii — Konvertierung von Zeichen in das ASCII-Format.
Benutzung
:
int toascii(int c);
Prototyp in
:
<ctype.h>
Beschreibung :
toascii() (to ASCII) konvertiert das in c gespeicherte Zeichen in ein
Standard-ASCII-Zeichen. Dabei werden alle Bits, bis auf die sieben niederwertigen Bits, auf 0 gesetzt.
Ist das Zeichen in c bereits ein ASCII- Zeichen, so erfolgt keine Konvertierung.
Um das Zeichen zu überprüfen, ob es es ein Standard- ASCII-Zeichen
ist, kann das Makro isascii() verwendet werden.
Return-Wert: :
Das Makro liefert einen int- Wert als Ergebnis der Konvertierung
zurück.
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion toascii()
#include <stdio.h>
#include <ctype.h>
int main(void)
{
int nummer, ergeb;
nummer = 225;
ergeb = toascii(nummer);
printf("%d %d\n", nummer, ergeb);
}
293
294
KAPITEL 4. FUNKTIONEN
4.162
tolower()
Name
:
tolower — wandelt Groß- in Kleinbuchstaben um.
#include
Benutzung
:
:
<ctype.h>
int tolower(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
tolower() (to lower) wandelt ein Großbuchstaben A . . . Z in ein Kleinbuchstaben um.
Return-Wert: :
Die Funktion liefert einen int-Wert zurück, falls c ein Großbuchstabe
ist; ansonsten ist das Ergebnis undefiniert.
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion tolower()
#include <string.h>
#include <stdio.h>
#include <ctype.h>
int main(void)
{
int length, i;
char *string = "DAS IST EIN STRING";
length = strlen(string);
for (i = 0; i < length; i++)
{
string[i] = tolower(string[i]);
}
printf("%s\n",string);
return 0;
}
4.163. TOUPPER()
4.163
295
toupper()
Name
:
toupper — wandelt Klein- in Großbuchstaben um.
#include
Benutzung
:
:
<ctype.h>
int toupper(int c);
Prototyp in
:
<ctype.h>
(ANSI)
Beschreibung :
toupper() (to upper) wandelt einen Kleinbuchstaben in einen Großbuchstaben um.
Für die korrekte Konvertierung muß das Zeichen c einen Wert im Bereich von 0 . . . 255 oder den Wert EOF haben.
Return-Wert: :
Die Funktion liefert einen int-Wert zurück, falls c ein Kleinbuchstabe
ist; ansonsten wird das Zeichen unverändert zurückgegeben.
Querverweis
:
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
Beispiel zur Funktion toupper()
#include <string.h>
#include <stdio.h>
#include <ctype.h>
int main(void)
{
int length, i;
char *string = "das ist ein string";
length = strlen(string);
for (i = 0; i < length; i++)
{
string[i] = toupper(string[i]);
}
printf("%s\n",string);
return 0;
}
296
KAPITEL 4. FUNKTIONEN
4.164
ungetc()
Name
:
ungetc — schreibt ein gelesenes Zeichen in eine Datei zurück. (ANSI)
#include
Benutzung
:
:
<stdio.h>
int ungetc(int c, FILE *fp);
Prototyp in
:
<stdio.h>
Beschreibung :
ungetc() (unget character) schreibt das gelesene Zeichen wieder in den
mit dem File-Pointer fp verbundenen Dateipuffer zurück. Eine darauf
folgende Leseoperation enthält das Zeichen c.
In der Regel kann ungetc() nur einmal aufgerufen werden, danach muß
ein Zeichen gelesen werden. Ein evtl. gesetztes EOF-Flag wird gelöscht.
Nach dem Lesen des zurückgestellten Zeichens ist die aktuelle Dateiposition dieselbe wie vor dem Zurückstellen des Zeichens. Das zurückgestellte Zeichen geht verloren, wenn die Dateiposition durch fseek(),
rewind(), oder fsetpos() verändert wird.
Return-Wert: :
Die Funktion liefert das Zeichen c zurück. Im Fehlerfall wird EOF
zurückgeben.
Querverweis
:
fgetc getc getchar
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.164. UNGETC()
Beispiel zur Funktion ungetc()
#include <stdio.h>
#include <ctype.h>
int main( void )
{
int i=0;
char ch;
puts("Geben Sie eine ganze Zahl, gefolgt "
"von einem Buchstaben ein: ");
/* liest Zeichen bis zur ersten Nichtziffer
oder bis EOF */
while((ch = getchar()) != EOF
&& isdigit(ch))
/* konvertiert ASCII in einen int-Wert */
i = 10 * i + ch - 48;
/* legt das Zeichen zurueck auf den EingabeStream, falls es nicht EOF war */
if (ch != EOF)
ungetc(ch, stdin);
printf("der int-Wert ist ’%d’, und ’%c’ ist"
" das naechste Zeichen im Puffer.\n",
i, getchar());
return 0;
}
297
298
4.165
KAPITEL 4. FUNKTIONEN
ungetch()
Name
:
ungetch — stellt ein gelesenes Zeichen von der Tastatur in den Tasturpuffer zurück.
#include
Benutzung
:
:
<conio.h>
int ungetch(int c, FILE *fp);
Prototyp in
:
<conio.h>
Beschreibung :
ungetch() (unget character) schreibt das gelesene Zeichen wieder in
den Tastaturpuffer zurück. Es kann nur ein Zeichen zurückgestellt werden. Eine darauf folgende Leseoperation erfolgt mit getch() oder getche().
Return-Wert: :
Die Funktion liefert das Zeichen c zurück. Im Fehlerfall wird EOF
zurückgeben.
Querverweis
:
getch getche
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : mit anderer Bedeutung
SunOS 4.1.x : nicht vorhanden
4.165. UNGETCH()
Beispiel zur Funktion ungetch()
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
int main( void )
{
int i=0;
char ch;
puts("Geben Sie eine ganze Zahl, gefolgt "
"von einem Buchstaben ein: ");
/* liest Zeichen bis zur ersten Nichtziffer
oder bis EOF */
while((ch = getch()) != EOF
&& isdigit(ch))
{ /* gibt das Zeichen am Bildschirm aus */
putch(ch);
/* konvertiert ASCII in einen int-Wert */
i = 10 * i + ch - 48;
}
/* legt das Zeichen zurueck auf den EingabeStream, falls es nicht EOF war */
if (ch != EOF)
ungetch(ch);
printf("\nder int-Wert ist ’%d’ und ’%c’"
"ist das naechste Zeichen im Stream.\n",
i, getch());
return 0;
}
299
300
KAPITEL 4. FUNKTIONEN
4.166
unlink()
Name
:
unlink — löscht eine Datei.
#include
Benutzung
:
:
<io.h>
int unlink(const char *filename);
Prototyp in
:
<dos.h io.h stdio.h>
Beschreibung :
unlink() (unlink) löscht die durch filename spezifizierte Datei, wobei
filenaname einen vollständigen Laufwerksbezeichner enthalten kann.
Jokerzeichen ∗ und ? sind nicht zulässig.
Schreibgeschützte Dateien oder Directories können mit unlink() nicht
gelöscht werden.
Return-Wert: :
Die Funktion liefert bei korrekter Durchführung den Wert 0 zurück.
Im Fehlerfall wird der Wert -1 zurückgegeben, und die Fehlervariable
errno erhält den Wert EACCES = permission denied bzw.
ENOENT = no such file or directory.
Querverweis
:
chmod remove
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : wie oben, Headerdatei ist <unistd.h>
SunOS 4.1.x : int unlink(char *filename)
Headerdatei ist <unistd.h>
4.166. UNLINK()
Beispiel zur Funktion unlink()
#include <stdio.h>
#include <io.h>
int main(void)
{
FILE *fp = fopen("junk.jnk","w");
int status;
fprintf(fp,"junk");
status = access("junk.jnk",0);
if (status == 0)
printf("Die Datei existiert.\n");
else
printf("Die Datei existiert nicht.\n");
fclose(fp);
unlink("junk.jnk");
status = access("junk.jnk",0);
if (status == 0)
printf("Die Datei existiert.\n");
else
printf("Die Datei existiert nicht.\n");
return 0;
}
301
302
KAPITEL 4. FUNKTIONEN
4.167
va arg()
Name
:
va arg, va end, va start — Makros für Funktionen variabler Parameterzahl.
(ANSI)
#include
Benutzung
:
:
<stdarg.h>
void va start(va list argptr, lastfix);
type va arg(va list argptr, type);
void va end(va list argptr);
Prototyp in
:
<stdarg.h>
Beschreibung :
Hinweis
:
Die Makros va start() und va arg() ermöglichen die Deklaration und
Aufrufe von Funktionen mit variabler Parameterzahl zu definieren. Die
Funktion muß mindestens ein festes Argument besitzen.
Das Makro va start() (variable start) initialisiert den Zeiger argptr
durch Setzen des Zeigers auf das erste optionale Argument. Dazu muß
für lastfix der Name des Parameters für das letzte Argument der Funktion angegeben werden.
Das Makro va arg() (variable argument) übergibt das nächste Argument der Funktion, auf das argptr zeigt. Dazu ist der Datentyp type des
Argumentes anzugeben. Anschließend wird argptr auf das nachfolgende variable Argument der Funktion gesetzt. Vor Nutzung von va arg()
muß das Makro va start() aufgerufen worden sein.
Das Makro va end() (variable end) sollte aufgerufen werden, wenn alle Argumente gelesen wurden. In der Regel wird dadurch argptr auf
NULL gesetzt.
Mit va arg() können keine Werte vom Typ char, unsigned char oder
float verwendet werden.
Return-Wert: :
Das Makro va arg() gibt das jeweils nächste Argument zurück.
Die Makros va start() und va end() besitzen keinen Return-Wert.
Querverweis
:
vprintf vscanf
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : nicht vorhanden
4.167. VA ARG()
Beispiel zur Funktion va arg()
#include <stdio.h>
#include <stdarg.h>
/* Summe ermitteln */
void sum(char *msg,...)
{
int total = 0;
va_list ap;
int arg;
va_start(ap,msg);
while ((arg = va_arg(ap,int)) != 0)
{
total += arg;
}
printf(msg,total);
}
int main(void)
{
sum("Die Summe von 1+2+3+4 ist %d\n",1,2,3,4,0);
return 0;
}
303
304
4.168
KAPITEL 4. FUNKTIONEN
vfprintf(), vprintf(), vsprintf()
Name
:
vfprintf, vprintf, vsprintf — formatierte Ausgabe mit Zeiger auf Argumentliste.
(ANSI)
#include
Benutzung
:
:
<stdio.h>
int vfprintf(FILE *fp, const char *formatstring, va list argptr);
int vprintf(const char *formatstring, va list argptr);
int vsprintf(char *buf, const char *formatstring, va list argptr);
Prototyp in
:
<stdio.h>
Beschreibung :
Die Funktionen vfprintf(), vprintf() und vsprintf() (variable . . . ) entsprechen den Funktionen fprintf(), printf() und sprintf(). Die v . . . Funktionen benötigen einen Zeiger auf die Argumentliste.
Return-Wert: :
Anzahl der ausgegebenen Zeichen.
Querverweis
:
vprintf vscanf printf va arg va start va end
Beispiel
:
s.u.
UNIX
:
Solaris 2.x / SunOS 4.1.x : wie oben
4.168. VFPRINTF(), VPRINTF(), VSPRINTF()
Beispiel zur Funktion vfprintf()
#include <stdio.h>
#include <stdlib.h>
FILE *fp;
int vfpf(char *fmt, ...)
{
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vfprintf(fp, fmt, argptr);
va_end(argptr);
return(cnt);
}
int main( void )
{
int inumber = 30;
float fnumber = 90.0;
char string[4] = "abc";
fp = tmpfile();
if (fp == NULL)
{
perror("Fehler beim Aufruf von "
"tmpfile()");
exit(1);
}
vfpf("%d %f %s",
inumber, fnumber, string);
rewind(fp);
fscanf(fp,"%d %f %s",
&inumber, &fnumber, string);
printf("%d %f %s\n",
inumber, fnumber, string);
fclose(fp);
return 0;
}
305
306
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion vprintf()
#include <stdio.h>
int vpf(char *fmt, ...)
{
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vprintf(fmt, argptr);
va_end(argptr);
return(cnt);
}
int main(void)
{
int inumber = 30;
float fnumber = 90.0;
char *string = "abc";
vpf("%d %f %s\n", inumber, fnumber, string);
return 0;
}
4.168. VFPRINTF(), VPRINTF(), VSPRINTF()
Beispiel zur Funktion vsprintf()
#include <stdio.h>
#include <conio.h>
char buffer[80];
int vspf(char *fmt, ...)
{
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vsprintf(buffer, fmt, argptr);
va_end(argptr);
return(cnt);
}
int main(void)
{
int inumber = 30;
float fnumber = 90.0;
char string[3] = "abc";
vspf("%d %f %s", inumber, fnumber, string);
printf("%s\n", buffer);
return 0;
}
307
308
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion vfscanf()
#include <stdio.h>
#include <stdlib.h>
FILE *fp;
int vfsf(char *fmt, ...)
{
va_list argptr;
int cnt;
va_start(argptr, fmt);
cnt = vfscanf(fp, fmt, argptr);
va_end(argptr);
return(cnt);
}
int main(void)
{
int inumber = 30;
float fnumber = 90.0;
char string[4] = "abc";
fp = tmpfile();
if (fp == NULL)
{
perror("Fehler bei tmpfile()");
exit(1);
}
fprintf(fp,"%d %f %s\n",
inumber, fnumber, string);
rewind(fp);
vfsf("%d %f %s",
&inumber, &fnumber, string);
printf("%d %f %s\n",
inumber, fnumber, string);
fclose(fp);
return 0;
}
4.169. WRITE()
4.169
309
write()
Name
:
write — schreibt Daten in eine Datei.
#include
Benutzung
:
:
<io.h>
int write(int fd, void *buffer, unsigned n);
Prototyp in
:
<io.h>
Beschreibung :
write() (write) schreibt n Bytes aus den durch buffer angegebenen
Speicherbereich in die mit dem File-Handle fd verbundenen Datei.
Wird die Datei im Modus text (DOS) eröffnet, dann wird der Zeilenvorschub \n in die Zeichenfolge CR \LF (0x0D, 0x0A) übersetzt.
Bei Diskettendateien schreibt write() ab der aktuellen Position.
Bei Gerätedateien ist eine Position nicht definiert – es wird direkt zum
Gerät geschrieben.
Mit write sollten max. 65534 Bytes geschrieben werden (am Stück).
Wurde die Datei im Modus Append – O APPEND geöffnet, wird ab
Dateiende geschrieben.
Return-Wert: :
Die Funktion liefert die tatsächlich geschriebenen Bytes als positive Integer zurück, wobei CR \LF als ein Byte gezählt werden.
Im Fehlerfall ist der Return-Wert -1 und die Fehlervariable errno erhält
folgende Werte:
errno
Bedeutung
EACCES Zugriff nicht gestattet
EBADF
ungültiger File-Handle,
Datei nicht offen
Querverweis
:
fgetpos fseek fsetpos
lseek rewind tell
Beispiel
:
s.u.
UNIX
:
Solaris 2.x : ssize t write(inf fd, const void *buffer,
size t n);
Headerdatei ist <unistd.h>
SunOS 4.1.x : int write(int fd char *buffer, int n);
für System V wie oben
Headerdatei ist <unistd.h>
310
KAPITEL 4. FUNKTIONEN
Beispiel zur Funktion write()
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys\stat.h>
#include <io.h>
#include <string.h>
int main(void)
{
int handle;
char string[40];
int length, res;
/*
Erzeugt die Datei "TEST.$$$" im aktuellen Directory und
schreibt einen String in die Datei. Falls "TEST.$$$"
bereits existiert, wird sie ueberschrieben.
*/
if ((handle = open("TEST.$$$",
O_WRONLY | O_CREAT | O_TRUNC,
S_IREAD | S_IWRITE)) == -1)
{
printf("Fehler beim Oeffnen der Datei.\n");
exit(1);
}
strcpy(string, "Hallo, Freunde!\n");
length = strlen(string);
if ((res = write(handle, string, length))
!= length)
{
printf("Fehler beim Schreiben der "
"Datei.\n");
exit(1);
}
printf("%d Bytes in die Datei "
"geschrieben.\n", res);
close(handle);
return 0;
}
Literaturverzeichnis
[1] BORLAND C++ 3.1
Programmierhandbuch, 1992.
[2] BORLAND C++ 3.1
Referenzhandbuch, 1992.
[3] Stefan und Georg Rudolph
Der C-Crash-Kurs
McGraw-Hill, 1990, ca. 45.- DM
Es ist nicht speziell auf dem Borland-Compiler zugeschnitten.
[4] Burkhard Sachs
Borland C++ und Turbo C++
Hanser, 1992, ca. 38.- DM
Es ist für den Anfänger empfehlenswert und berücksichtigt das
“Handling“ der Programmierumgebung. Deckt aber den Umfang des
Kurses nicht ab.
[5] Gerd Kebschull
Turbo C++
Vogel-Verlag, 1990, ca. 58.- DM
Ist besonders als Handbuchergänzung geeignet, enthält viele
Beispiele und die Darstellung der Bibliotheksfunktionen.
[6] H. Herold, W. Unger
C - Gesamtwerk
tewi, 1988, ca. 79.- DM
Compilerunabhängiges Werk, das viele Beispiele und Erläuterungen
enthält. Auch kompliziertere Datenstrukturen und etwas weiter
führende Programmierungstechnik werden dargestellt.
[7] Uwe Repplinger
Turbo C++ - Einführung und Leitfaden
Addison Welsey, 1991
Ein Nachschlagwerk und Handbucherergänzung, Übersicht über
Bibliotheksfunktionen. Der C-Grundumfang wird erläutert.
311
312
LITERATURVERZEICHNIS
[8] Guido Krüger
C - Programmierung
Addison Wesley, 1991, ca. 69.- DM
Ist mit vielen Trainingsaufgaben zum vertiefenden Selbststudium
geeignet.
[9] Brian W. Kernigan, Dennis Ritchie
Programmieren in C
Hanser und Prentice-Hall, 2.Aufl. 1990, ca. 56.- DM
Der Klassiker und allgemeine Referenzquelle, 2.Auflage hat ANSI
berücksichtigt, ist eher Unix-bezogen.
[10] Robert Sedgewick
Algorithmen in C
Addison-Wesley, 1992, ca. 90.- DM
Ein leicht verständliches, umfangreiches und modernes
(Nachschlage-) Werk über Algorithmen, Datenstrukturen
und Programmiermethoden.
[11] Matthias Clauss, Guenther Fischer
Programmieren mit C
Hüthig, 1989, ca. 48.- DM
Unix-orientiert werden vor allen komplexe Verfahren erläutert,
nach knapper Einführung mit exakter Begriffsbildung wird etwas
Informatik- und Programmierwissen vorausgesetzt.
[12] L.H. Miller, A.E. Quilici
C in der Praxis
Oldenbourg, 2.Auflage 1990, ca. 68.- DM
Sehr ausführliche Darstellung der C-Elemente und Datenstrukturen,
nicht auf Borland-C bezogen.
[13] Harry Feldmann
Strukturiertes Programmieren in C
Vieweg, 1992, ca. 50.- DM
Dieses Buch orientiert sich stark an ADA-ähnlichem Stil
der Strukturierung.
Handbüchersätze Microsoft/Borland usw. sind fast unverzichtbar
beim konkreten Umgang mit einem der Compiler.
LITERATURVERZEICHNIS
Weiterführende Bücher von C++ :
[14] Walter Herglotz
C++ Grundlagen objektorientierter Programmierung
BHV, 1991, ca. 20.- DM
[15] Stanley B. Lippman
C++ Einführung und Leitfaden
Addison-Wesley, 2.Aufl. 1991, ca. 89.- DM
[16] Martin Aupperle
Objektorientiert mit Turbo C++
Vieweg, 1992
313