1// Literatur:
2// C++ Referenz (http://www.cplusplus.com)
3// C von A bis Z (http://openbook.galileocomputing.de/c_von_a_bis_z)
4
5
6// Programm Einsprung-Punkt
7 int main(int argc, char **argv)
8 {
9 return 0;
10 }
11
12 // argc ... Argumenten Counter
13 // argv ... Argumenten Liste
14
15
16// reservierte Schluesselwoerter
17 auto break case char complex const continue
18 default do double else enum extern float
19 for goto if imaginary inline int long
20 register restrict return short signed sizeof static
21 struct switch typedef union unsigned void volatile
22 while
23
24
25// Verfuegbare Zeichen
26 // Ziffern:
27 // 1 2 3 4 5 6 7 8 9 0
28 // Buchstaben:
29 // A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
30 // a b c d e f g h i j k l m n o p q r s t u v w x y z
31 // Sonderzeichen:
32 // ! " % & / ( ) [ ] { } \ ? = ' # + * ~ - _ . : ; , | < > ^
33 // Steuerzeichen:
34 // \a ... bell - akustisches Warnsignal
35 // \b ... backspace - Cursor nach links
36 // \f ... formfeed - Seitenvorschub durchfuehren
37 // \n ... newline - Cursor zur naechsten Zeile
38 // \r ... carriage return - Cursor zum Anfang der
39 // - aktuellen Zeile
40 // \t ... horizontal tab - Cursor zur naechsten horizontalen
41 // Tabulatorposition
42 // \v ... vertical tab - Cursor zur naechsten vertikalen
43 // Tabulatorposition
44 // \" ... Ausgabe: "
45 // \' ... Ausgabe: '
46 // \? ... Ausgabe: ?
47 // \\ ... Ausgabe: \
48 // \0 ... Stringabschluss (Byte-Wert 0 wird gespeichert)
49 // \nnn ... Ausgabe eines Oktalwerts
50 // \xhh ... Ausgabe eines Hexdezimalwerts
51
52
53// Kommentare
54 // Zeilenkommentar
55 /* Blockkommentar,
56 kann auch ueber mehrere Zeilen gehen */
57
58
59// Datentypen
60 // Speicherorte
61 // Code ... Programmcode
62 // Daten ... statische und globale Variablen
63 // Stack ... lokale Variablen
64 // Heap ... dynamische Variablen
65
66 // Initialisierung
67 int wert;
68 int wert = 5;
69 int wert1, wert2 = 10;
70 int wert1 = wert1 = 10;
71 int wert1 = 20, wert2 = 30;
72
73 int wert; // globale Variable
74 void main()
75 {
76 int wert; // lokale Variable
77
78 if ()
79 {
80 int wert; // blendet in diesem Anweisungsblock
81 } // andere lokale Variable aus
82 }
83
84 short // Ganzzahl ... Datentyp
85 // min 2 Byte ... ANSI-C
86 // -32.768 ... Min
87 // +32.767 ... Max
88
89 int // Ganzzahl (%d, %i)
90 // min 2 Byte
91 // -32.768
92 // +32.767
93
94 long // Ganzzahl (%ld, %li)
95 // min 4 Byte
96 // -2.147.483.648
97 // +2.147.483.647
98
99 long long // Ganzzahl
100 // min 8 Byte
101 // -9.223.372.036.854.755.807
102 // +9.223.372.036.854.755.807
103
104 float // Gleitkommazahl (%f)
105 // min 4 Byte
106 // 1.2E-38
107 // 3.4E+38
108 // Vorzeichen 1 Bit, Exponent 8 Bits, Mantisse 23 Bits
109
110 double // Gleitkommazahl (%lf)
111 // min 8 Byte
112 // 2.3E-308
113 // 1.7E+308
114 // 15-stellig
115 // Vorzeichen 1 Bit, Exponent 11 Bits, Mantisse 52 Bits
116
117 long double // Gleitkommazahl (%Lf)
118 // min 10 Byte
119 // 3.4E-4932
120 // 1.1E+4932
121 // 19-stellig
122
123 char // Zeichen (%c)
124 // 1 Byte
125 // -128
126 // +127
127
128
129 signed // ... negative und positive Zahl
130 unsigned // ... positive Zahl
131 const // ... Wert kann nicht veraendert werden
132 volatile // ... Variable kann sich auch asserhalb des Programms
133 // aendern (z.B. durch HW)
134 // -> Wert wird jedesmal neu eingelesen
135 static // ... bei Wiedereintritt bleibt Variable erhalten /
136 // Variable gilt nur im aktuellen Kontext
137 extern // ... Variable wurde in einer anderen Datei definiert
138 register // ... Variable sollte moeglichst lange in den internen
139 // Registern gehalten werden
140 (float) intVal // Typcast
141 float (intVal) // Typcast
142
143 int arr[10]; // Array-Definition (0-9)
144 arr[0] = *(arr + 0) // Zugriff auf Elemente
145 int arr[4][4]; // mehrdimensionale Arrays:
146 // [0][0] [0][1] [0][2] [0][3]
147 // [1][0] [1][1] ...
148 // ...
149 int Matrix[4][4] = {{1 ,2 ,3 ,4 },
150 {4 ,5 ,6 ,7 },
151 {8 ,9 ,10,11},
152 {12,13,14,15}};
153 sizeof(arr)/sizeof(int) // Array Elemente ermitteln
154 int memcmp(const void *ptr1, const void *ptr2, size_t num);
155 void *memcpy(void *destination, const void *source, size_t num);
156
157 char str[] = "hello world\0";
158 // String verbinden
159 char *strcat(char *destination, const char *source);
160 // Zeichen in String suchen
161 const char *strchr( const char *str, int character);
162 // String vergleichen
163 int strcmp(const char *str1, const char *str2);
164 // String kopieren
165 char *strcpy(char *destination, const char *source);
166 // Teilstring ermitteln
167 size_t strcspn(const char *str1, const char *str2);
168 // String-Laenge ermitteln
169 size_t strlen(const char *str);
170 // String mit n Zeichen verbinden
171 char *strncat(char *destination, char *source, size_t num);
172 // String mit n Zeichen vergleichen
173 int strncmp(const char *str1, const char *str2, size_t num);
174 // String mit n Zeichen kopieren
175 char *strncpy(char *destination, const char *source, size_t num);
176 // erste Auftreten eines Zeichens
177 const char *strpbrk(const char *str1, const char *str2);
178 // letzte Auftreten eines Zeichens
179 const char *strrchr(const char *str, int character);
180 // erstes Auftreten eines Zeichens, das nicht vorkommt
181 size_t strspn(const char *str1, const char *str2);
182 // String nach Teilstring durchsuchen
183 const char *strstr(const char *str1, const char *str2);
184 // String anhand bestimmter Zeichen zerlegen
185 char *strtok(char *str, const char *delimiters);
186
187 sizeof(int) // ... Groesse des Datentyps in Byte
188
189 #include <limits.h>
190 CHAR_BIT
191 SCHAR_MIN SCHAR_MAX
192 UCHAR_MAX
193 CHAR_MIN CHAR_MAX
194 SHRT_MIN SHRT_MAX
195 USHRT_MAX
196 INT_MIN INT_MAX
197 UINT_MAX
198 LONG_MIN LONG_MAX
199 ULONG_MAX
200
201 #include <float.h>
202 FLT_RADIX FLT_MANT_DIG FLT_DIG FLT_MIN_EXP FLT_MIN_10_EXP
203 FLT_MAX_EXP FLT_MAX_10_EXP FLT_MAX FLT_MIN FLT_EPSILON
204
205 DBL_MANT_DIG DBL_DIG DBL_MIN_EXP DBL_MIN_10_EXP DBL_MAX_EXP
206 DBL_MAX_10_EXP DBL_MAX DBL_MIN DBL_EPSILON
207
208 LDBL_MANT_DIG LDBL_DIG LDBL_MIN_EXP LDBL_MIN_10_EXP LDBL_MAX_EXP
209 LDBL_MAX_10_EXP LDBL_MAX LDBL_MIN LDBL_EPSILON
210
211 int integer = 0;
212 int *pInt; // Pointer auf Integer-Datentyp
213 pInt = &integer; // Zeiger auf Variable
214 *pInt = 1; // Dereferenzieren - Wert aendern
215 pInt = 1; // Zeiger-Wert aendern
216
217 const int *pInt // Pointer auf konstanten Integer
218 int const *pInt // konstanter Pointer auf Integer
219 const int const *pInt // konstanter Pointer auf konstanten Integer
220
221 int Int;
222 int *pInt = ∬
223 int **ppInt = &pInt;
224 **ppInt = 10;
225 *pInt = 20;
226
227 // dynamischen Speicher anfordern
228 void *malloc(size_t size);
229 // dynamischen Speicher anfordern
230 void *calloc(size_t anzahl, size_t groesse);
231 // Speichergroesse anpassen
232 void *realloc(void *zgr, size_t neuegroesse);
233 // Speicher freigeben
234 free(void *p);
235 // Speicher vom Stack anfordern (braucht nicht freigegeben zu werden)
236 void *alloca(size_t size);
237
238
239// Typdefinitionen
240 typedef unsigned char BYTE;
241 typedef unsigned int WORD;
242
243
244// Strukturen, Unions, ...
245 struct Struct
246 {
247 int Value1;
248 char Value2;
249 };
250 struct Struct Struct1;
251 Struct1.Value1 = 0;
252 Struct1.Value2 = 'a';
253
254 typedef struct Struct
255 {
256 ...
257 } Struct_t;
258 Struct_t Struct1;
259
260 struct Struct
261 { ...
262 } Struct1;
263
264 struct Struct
265 { ...
266 } Struct1 = {0, 'a'};
267
268 struct Struct
269 {
270 int *ptr;
271 } Struct1;
272 Struct1->ptr = 10;
273
274
275 union Union
276 {
277 int Int;
278 long Long; // int und long werden am selben
279 }; // Speicherplatz abgelegt
280
281
282 enum Zahl {EINS, ZWEI};
283 enum Zahl {EINS=1, ZWEI};
284 enum Zahl nr = EINS;
285
286 typedef enum Zahl {EINS, ZWEI} Zahl_t;
287 Zahl_t nr = EINS;
288
289
290 typedef struct bit8struct
291 {
292 unsigned char b0:1; // Bit-weiser Zugriff
293 unsigned char b1:1;
294 unsigned char b2:1;
295 unsigned char b3:1;
296 unsigned char b4:1;
297 unsigned char b5:1;
298 unsigned char b6:1;
299 unsigned char b7:1;
300 } BITDEF8;
301
302 typedef union bit8union
303 {
304 BITDEF8 bit;
305 unsigned char byte;
306 } BIT8;
307
308
309// Operationen
310 // unaer ... ein Operanden
311 // binaer ... zwei Operanden
312 // ternaer ... drei Operanden
313
314 // infix ... Operand zwischen Operanden
315 // praefix ... Operand vor Operand
316 // postfix ... Operand nach Operand
317
318 // linksassoziativ ... a + b - c = (a + b) - c
319 // rechtsassoziativ ... a + b - c = a + (b - c)
320
321 // Berechnungsoperationen
322 a = a+b; // Addition
323 a = a-b; // Subtraktion
324 a = a*b; // Multiplikation
325 a = a/b; // Division
326 a = a%b; // Modulo (Rest)
327
328 a += b;
329 a -= b;
330 a *= b;
331 a /= b;
332 a %= b;
333
334 a++; // postfix - alte Wert wird ausgegeben und
335 // anschliessend wird incrementiert
336 ++a; // praefix - Wert wird inkrementier und
337 // anschliessend ausgegeben
338 b--; // dekrementieren
339 --b;
340
341 // Bitoperationen
342 & // bitweises Und
343 | // bitweises Oder
344 ^ // bitweises XOR
345 ~ // bitweises Komplement
346 >> // shift right
347 << // shift left
348
349 // Vergleichsoperatoren
350 == // gleich
351 != // ungleich
352 < // kleiner
353 > // groesser
354 <= // kleiner gleich
355 >= // groesser gleich
356
357 ! // negation
358 || // Oder
359 && // Und
360
361
362// Kontrollanweisungen
363 if (CONDITION)
364 {}
365 else if (CONDITION)
366 {}
367 else
368 {}
369
370 if (a>b) == c = (a>b) ? a : b;
371 c = a;
372 else
373 c = b;
374
375 switch(a)
376 {
377 case 0:
378 break;
379 default:
380 break;
381 }
382
383 while (CONDITION)
384 {}
385
386 do
387 {}
388 while (CONDITION);
389
390 for (i=0; i<MAX; i++)
391 {}
392
393
394// Funktionen
395 void FuncName (int Param); // Vorwaertsdeklaration
396 void FuncName (int Param) // Implementierung
397 {}
398
399 void FuncName (int Value) // call by value
400 {} // Kopie wird uebertragen,
401 // Aenderung wirkt sich ausserhalb
402 // nicht aus
403
404 void FuncName (int *Value) // call by reference
405 {} // Pointer wird uebertragen,
406 // Aenderung wirkt sich ausserhalb aus
407
408 void FuncName (int Arr[])
409 {
410 Arr[0] = ...
411 }
412 void FuncName (int Arr[][10])
413 {
414 Arr[0][0] = ...
415 }
416
417 int *FuncName ()
418 {
419 int asdf = 0;
420 return asdf; // !Fehler!
421 // -> Variable nach Funktionsende
422 // nicht mehr am Stack
423
424 int *asdf = (int *) malloc(sizeof(int));
425 *asdf = 0;
426 return asdf; // Richtig -> Variable bleibt erhalten
427 }
428
429
430// Funktionspointer
431 int (*FuncName)(void);
432 int (*FuncName)(int Value);
433 int (*FuncName)(int Value, ...);
434 FuncName pFunc = ...
435
436 int (*ptr[])(const char *, ...) = { scanf, printf };
437 (*ptr[1])("output");
438 (*ptr[0])("%d",&value);
439
440
441// formatierte Ausgabe
442 printf("hello world");
443 printf("hello \
444 world");
445
446 printf("%FW.GU", &value);
447 // F ... Flags
448 // W ... Weite
449 // G ... Genauigkeit
450 // U ... Formatierungszeichen
451
452 // Flags:
453 // - ... linksbuendig
454 // 0 ... mit 0en fuellen
455 // + ... Vorzeichen ausgeben
456 // blank ... positive Zahlen mit Leerzeichen beginnen
457 // # ... verschiedene Bedeutung:
458 // %#o (Oktal) 0 Praefix einfuegen
459 // %#x (Hex) 0x Praefix einfuegen (Wert ungl. Null)
460 // %#X (Hex) 0X Praefix einfuegen (Wert ungl. Null)
461 // %#e Dezimalpunkt anzeigen
462 // %#E Dezimalpunkt anzeigen
463 // %#f Dezimalpunkt anzeigen
464 // %#g Dezimalpunkt immer anzeigen. 0en nach dem
465 // Dezimalpunkt werden nicht beseitigt
466 // %#G Dezimalpunkt immer anzeigen. 0en nach dem
467 // Dezimalpunkt werden nicht beseitigt
468
469 // Formatierungszeichen:
470 // %d, %i ... vorzeichenbehaftete ganze Dezimalzahl
471 // %o ... vorzeichenlose ganze Oktalzahl
472 // %u ... vorzeichenlose ganze Dezimalzahl
473 // %x, %X ... vorzeichenlose ganze Hexzahl
474 // (a,b,c,d,e,f) bei x; (A,B,C,D,E,F) bei X
475 // %f ... Gleitpunktzahl (ddd.dddddd)
476 // %e, %E ... Gleitpunktzahl (d.ddde+-dd, d.dddE+-dd)
477 // %g, %G ... float
478 // %c ... Zeichen
479 // %s ... Zeichenkette
480 // %p ... Zeigerwerte
481 // %% ... das Zeichen %
482
483
484// formatiere Eingabe
485 #include <stdio.h>
486 nrCorrect = scanf("%d %c",&i, &c);
487 // nrCorrect ... Nummer der korrekt eingelesenen Werte
488
489 // Suchmengen
490 %[Liste] // Zeichen welches in der Liste befindet
491 // %[A-Z] %[a-z] %[a-fA-F]
492 %[^Liste] // Zeichen welches nicht in der Liste befindet
493
494 fflush(stdin); // Eingabe-Puffer leeren
495
496
497// standard Libraries
498 // assert.h ... Fehlersuche und Debugging
499 // ctype.h ... Zeichentest und Konvertierung
500 // errno.h ... Fehlercodes
501 // float.h ... Limits/Eigenschaften fuer Gleitpunkttypen
502 // limits.h ... Implementierungskonstanten
503 // locale.h ... Laenderspezifische Eigenschaften
504 // math.h ... Mathematische Funktionen
505 // setjmp.h ... Unbedingte Spruenge
506 // signal.h ... Signale
507 // stdarg.h ... Variable Parameteruebergabe
508 // stddef.h ... Standard-Datentyp
509 // stdio.h ... Standard-I/O
510 // stdlib.h ... Nuetzliche Funktionen
511 // string.h ... Zeichenkettenoperationen
512 // time.h ... Datum und Uhrzeit
513 // complex.h ... Komplexe Arithmetik
514 // inttypes.h ... Fuer genauere Integer-Typen
515 // stdbool.h ... Boolschen Datentypen
516 // stdint.h ... Ganzzahlige Typen mit vorgegebener Breite
517 // tgmath.h ... Generische Mathematik-Funktionen
518 // wchar.h ... fuer den erweiterten Zeichensatz:
519 // - Umwandlung von Strings zu Zahlwerten
520 // - String- und Speicherbearbeitung
521 // - Ein- und Ausgabe
522 // wctype.h ... fuer den erweiterten Zeichensatz:
523 // - Zeichenuntersuchung
524
525
526// Dateioperationen
527 // Datenstrom oeffnen
528 FILE *fopen(const char *pfadname, const char *modus);
529 // r ... read
530 // w ... write (anlegen einer Datei)
531 // a ... write/add (falls nicht vorhanden -> NULL)
532 // r+ ... read+write
533 // w+ ... write (falls vorhanden -> zuvor loeschen)
534 // a+ ... write/add (falls nicht vorhanden -> anlegen)
535 //
536 // b ... Binaermodus
537 // t ... Textmodus
538 //
539 // stdin ... Standardeingabe
540 // stdout ... Standardausgabe
541 // stderr ... Standardfehlerausgabe
542 // Datenstrom schliessen
543 int fclose(FILE *stream);
544 // Testet auf Dateiende im Stream
545 int feof(FILE *stream);
546 // Testet auf Fehler im Stream
547 int ferror(FILE *stream);
548 // Leert den Puffer im Datenstrom
549 int fflush(FILE *stream);
550 // Zeichenweise lesen vom Stream
551 int fgetc(FILE *stream);
552 // Zeilenweise lesen vom Stream
553 char *fgets(char *str, int num, FILE *stream);
554 // Position im Stream ermitteln
555 int fgetpos(FILE *stream, fpos_t *position);
556 // Formatierte Ausgabe an Stream
557 int fprintf(FILE *stream, const char *format, ... );
558 // Zeichenweise schreiben in den Stream
559 int fputc(int character, FILE *stream);
560 // Schreibt einen String in den Stream
561 int fputs(const char *str, FILE *stream);
562 // Datenstrom erneut oeffnen
563 FILE *freopen(const char *filename, const char *mode, FILE *stream);
564 // Formatierte Eingabe vom Stream
565 int fscanf(FILE *stream, const char *format, ... );
566 // Dateizeiger neu positionieren
567 int fseek(FILE *stream, long int offset, int origin);
568 // Dateizeiger neu positionieren
569 int fsetpos(FILE *stream, const fpos_t *pos);
570 // Position im Stream ermitteln
571 long int ftell(FILE *stream);
572
573 // Zeichenweise lesen vom Stream
574 int getc(FILE *stream);
575 // Zeichenweise lesen von stdin
576 int getchar(void);
577 // Liest String von stdin (unsichereFunktion)
578 char *gets(char *str);
579 // Formatierte Ausgabe an stdout
580 int printf(const char *format, ... );
581 // Zeichenweise schreiben in den Stream
582 int putc(int character, FILE *stream);
583 // Zeichenweise schreiben an stdout
584 int putchar(int character);
585 // Zeichenkette an Stream stdout
586 int puts(const char *str);
587 // Formatierte Eingabe von stdin
588 int scanf(const char *format, ... );
589 // Streampuffer einrichten
590 void setbuf(FILE *stream, char *buffer);
591 // Streampuffer veraendern
592 int setvbuf(FILE *stream, char *buffer, int mode, size_t size);
593 // Formatierte Ausgabe in einem String
594 int sprintf(char *str, const char *format, ... );
595 // Formatierte Eingabe aus einem String
596 int sscanf(const char *str, const char *format, ...);
597 // Zeichen zurueck in den Stream
598 int ungetc(int character, FILE *stream );
599
600
601// Fehlercodes
602 <errno.h>
603 strerror(), perror()
604 // EDOM ... Unzulaessiges Argument fuer eine
605 // mathematische Funktion
606 // ERANGE ... Ergebnis ausserhalb des darstellbaren Bereichs
607 // EZERO ... Fehler 0
608 // EINVFNC ... Ungueltige Funktionsnummer
609 // ENOFILE ... Datei nicht gefunden
610 // ENOPATH ... Pfad nicht gefunden
611 // ECONTR ... Speicherbloecke zerstoert
612 // EINVMEM ... Ungueltige Speicherblockadresse
613 // EINVENV ... Ungueltiges Environment
614 // EINVFMT ... Ungueltiges Format
615 // EINVACC ... Ungueltiger Zugriffscode
616 // EINVDAT ... Ungueltige Daten
617 // EINVDRV ... Ungueltige Laufwerksangabe
618 // ECURDIR ... Versuch, das aktuelle Verzeichnis zu loeschen
619 // ENOTSAM ... Nicht das gleiche Geraet
620 // ENMFILE ... Keine weiteren Dateien mehr
621 // ENOENT ... Datei oder Verzeichnis existiert nicht
622 // EMFILE ... Zu viele geoeffnete Dateien
623 // EACCES ... Zugriff verweigert
624 // EBADF ... Ungueltiger Datei-Deskriptor
625 // ENOMEM ... Zu wenig Speicher
626 // ENODEV ... Geraet existiert nicht
627 // EINVAL ... Ungueltiges Argument
628 // E2BIG ... Argumentliste ist zu lang
629 // ENOEXEC ... Fehler beim Exec-Format
630 // EXDEV ... Kreuzverbindung von Geraeten
631 // EFAULT ... Unbekannter Fehler
632 // EEXIST ... Datei existiert bereits
