// Literatur: // C++ Referenz (http://www.cplusplus.com) // C von A bis Z (http://openbook.galileocomputing.de/c_von_a_bis_z) // Programm Einsprung-Punkt int main(int argc, char **argv) { return 0; } // argc ... Argumenten Counter // argv ... Argumenten Liste // reservierte Schluesselwoerter auto break case char complex const continue default do double else enum extern float for goto if imaginary inline int long register restrict return short signed sizeof static struct switch typedef union unsigned void volatile while // Verfuegbare Zeichen // Ziffern: // 1 2 3 4 5 6 7 8 9 0 // Buchstaben: // 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 // 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 // Sonderzeichen: // ! " % & / ( ) [ ] { } \ ? = ’ # + * ~ – _ . : ; , | < > ^ // Steuerzeichen: // \a ... bell – akustisches Warnsignal // \b ... backspace – Cursor nach links // \f ... formfeed – Seitenvorschub durchfuehren // \n ... newline – Cursor zur naechsten Zeile // \r ... carriage return – Cursor zum Anfang der // aktuellen Zeile // \t ... horizontal tab – Cursor zur naechsten horizontalen // Tabulatorposition // \v ... vertical tab – Cursor zur naechsten vertikalen // Tabulatorposition // \" ... Ausgabe: " // \’ ... Ausgabe: ' // \? ... Ausgabe: ? // \\ ... Ausgabe: \ // \0 ... Stringabschluss (Byte-Wert 0 wird gespeichert) // \nnn ... Ausgabe eines Oktalwerts // \xhh ... Ausgabe eines Hexdezimalwerts // Kommentare // Zeilenkommentar /* Blockkommentar, kann auch ueber mehrere Zeilen gehen */ // Datentypen // Speicherorte // Code ... Programmcode // Daten ... statische und globale Variablen // Stack ... lokale Variablen // Heap ... dynamische Variablen // Initialisierung int wert; int wert = 5; int wert1, wert2 = 10; int wert1 = wert1 = 10; int wert1 = 20, wert2 = 30; int wert; // globale Variable void main() { int wert; // lokale Variable if () { int wert; // blendet in diesem Anweisungsblock } // andere lokale Variable aus } short // Ganzzahl ... Datentyp // min 2 Byte ... ANSI-C // -32.768 ... Min // +32.767 ... Max int // Ganzzahl (%d, %i) // min 2 Byte // -32.768 // +32.767 long // Ganzzahl (%ld, %li) // min 4 Byte // –2.147.483.648 // +2.147.483.647 long long // Ganzzahl // min 8 Byte // –9.223.372.036.854.755.807 // +9.223.372.036.854.755.807 float // Gleitkommazahl (%f) // min 4 Byte // 1.2E-38 // 3.4E+38 // Vorzeichen 1 Bit, Exponent 8 Bits, Mantisse 23 Bits double // Gleitkommazahl (%lf) // min 8 Byte // 2.3E-308 // 1.7E+308 // 15-stellig // Vorzeichen 1 Bit, Exponent 11 Bits, Mantisse 52 Bits long double // Gleitkommazahl (%Lf) // min 10 Byte // 3.4E-4932 // 1.1E+4932 // 19-stellig char // Zeichen (%c) // 1 Byte // -128 // +127 signed // ... negative und positive Zahl unsigned // ... positive Zahl const // ... Wert kann nicht veraendert werden volatile // ... Variable kann sich auch asserhalb des Programms // aendern (z.B. durch HW) // -> Wert wird jedesmal neu eingelesen static // ... bei Wiedereintritt bleibt Variable erhalten / // Variable gilt nur im aktuellen Kontext extern // ... Variable wurde in einer anderen Datei definiert register // ... Variable sollte moeglichst lange in den internen // Registern gehalten werden (float) intVal // Typcast float (intVal) // Typcast int arr[10]; // Array-Definition (0-9) arr[0] = *(arr + 0) // Zugriff auf Elemente int arr[4][4]; // mehrdimensionale Arrays: // [0][0] [0][1] [0][2] [0][3] // [1][0] [1][1] ... // ... int Matrix[4][4] = {{1 ,2 ,3 ,4 }, {4 ,5 ,6 ,7 }, {8 ,9 ,10,11}, {12,13,14,15}}; sizeof(arr)/sizeof(int) // Array Elemente ermitteln int memcmp(const void *ptr1, const void *ptr2, size_t num); void *memcpy(void *destination, const void *source, size_t num); char str[] = "hello world\0"; // String verbinden char *strcat(char *destination, const char *source); // Zeichen in String suchen const char *strchr( const char *str, int character); // String vergleichen int strcmp(const char *str1, const char *str2); // String kopieren char *strcpy(char *destination, const char *source); // Teilstring ermitteln size_t strcspn(const char *str1, const char *str2); // String-Laenge ermitteln size_t strlen(const char *str); // String mit n Zeichen verbinden char *strncat(char *destination, char *source, size_t num); // String mit n Zeichen vergleichen int strncmp(const char *str1, const char *str2, size_t num); // String mit n Zeichen kopieren char *strncpy(char *destination, const char *source, size_t num); // erste Auftreten eines Zeichens const char *strpbrk(const char *str1, const char *str2); // letzte Auftreten eines Zeichens const char *strrchr(const char *str, int character); // erstes Auftreten eines Zeichens, das nicht vorkommt size_t strspn(const char *str1, const char *str2); // String nach Teilstring durchsuchen const char *strstr(const char *str1, const char *str2); // String anhand bestimmter Zeichen zerlegen char *strtok(char *str, const char *delimiters); sizeof(int) // ... Groesse des Datentyps in Byte #include <limits.h> CHAR_BIT SCHAR_MIN SCHAR_MAX UCHAR_MAX CHAR_MIN CHAR_MAX SHRT_MIN SHRT_MAX USHRT_MAX INT_MIN INT_MAX UINT_MAX LONG_MIN LONG_MAX ULONG_MAX #include <float.h> FLT_RADIX FLT_MANT_DIG FLT_DIG FLT_MIN_EXP FLT_MIN_10_EXP FLT_MAX_EXP FLT_MAX_10_EXP FLT_MAX FLT_MIN FLT_EPSILON DBL_MANT_DIG DBL_DIG DBL_MIN_EXP DBL_MIN_10_EXP DBL_MAX_EXP DBL_MAX_10_EXP DBL_MAX DBL_MIN DBL_EPSILON LDBL_MANT_DIG LDBL_DIG LDBL_MIN_EXP LDBL_MIN_10_EXP LDBL_MAX_EXP LDBL_MAX_10_EXP LDBL_MAX LDBL_MIN LDBL_EPSILON int integer = 0; int *pInt; // Pointer auf Integer-Datentyp pInt = &integer; // Zeiger auf Variable *pInt = 1; // Dereferenzieren - Wert aendern pInt = 1; // Zeiger-Wert aendern const int *pInt // Pointer auf konstanten Integer int const *pInt // konstanter Pointer auf Integer const int const *pInt // konstanter Pointer auf konstanten Integer int Int; int *pInt = ∬ int **ppInt = &pInt; **ppInt = 10; *pInt = 20; // dynamischen Speicher anfordern void *malloc(size_t size); // dynamischen Speicher anfordern void *calloc(size_t anzahl, size_t groesse); // Speichergroesse anpassen void *realloc(void *zgr, size_t neuegroesse); // Speicher freigeben free(void *p); // Speicher vom Stack anfordern (braucht nicht freigegeben zu werden) void *alloca(size_t size); // Typdefinitionen typedef unsigned char BYTE; typedef unsigned int WORD; // Strukturen, Unions, ... struct Struct { int Value1; char Value2; }; struct Struct Struct1; Struct1.Value1 = 0; Struct1.Value2 = 'a'; typedef struct Struct { ... } Struct_t; Struct_t Struct1; struct Struct { ... } Struct1; struct Struct { ... } Struct1 = {0, 'a'}; struct Struct { int *ptr; } Struct1; Struct1->ptr = 10; union Union { int Int; long Long; // int und long werden am selben }; // Speicherplatz abgelegt enum Zahl {EINS, ZWEI}; enum Zahl {EINS=1, ZWEI}; enum Zahl nr = EINS; typedef enum Zahl {EINS, ZWEI} Zahl_t; Zahl_t nr = EINS; typedef struct bit8struct { unsigned char b0:1; // Bit-weiser Zugriff unsigned char b1:1; unsigned char b2:1; unsigned char b3:1; unsigned char b4:1; unsigned char b5:1; unsigned char b6:1; unsigned char b7:1; } BITDEF8; typedef union bit8union { BITDEF8 bit; unsigned char byte; } BIT8; // Operationen // unaer ... ein Operanden // binaer ... zwei Operanden // ternaer ... drei Operanden // infix ... Operand zwischen Operanden // praefix ... Operand vor Operand // postfix ... Operand nach Operand // linksassoziativ ... a + b - c = (a + b) - c // rechtsassoziativ ... a + b - c = a + (b - c) // Berechnungsoperationen a = a+b; // Addition a = a-b; // Subtraktion a = a*b; // Multiplikation a = a/b; // Division a = a%b; // Modulo (Rest) a += b; a -= b; a *= b; a /= b; a %= b; a++; // postfix - alte Wert wird ausgegeben und // anschliessend wird incrementiert ++a; // praefix - Wert wird inkrementier und // anschliessend ausgegeben b--; // dekrementieren --b; // Bitoperationen & // bitweises Und | // bitweises Oder ^ // bitweises XOR ~ // bitweises Komplement >> // shift right << // shift left // Vergleichsoperatoren == // gleich != // ungleich < // kleiner > // groesser <= // kleiner gleich >= // groesser gleich ! // negation || // Oder && // Und // Kontrollanweisungen if (CONDITION) {} else if (CONDITION) {} else {} if (a>b) == c = (a>b) ? a : b; c = a; else c = b; switch(a) { case 0: break; default: break; } while (CONDITION) {} do {} while (CONDITION); for (i=0; i<MAX; i++) {} // Funktionen void FuncName (int Param); // Vorwaertsdeklaration void FuncName (int Param) // Implementierung {} void FuncName (int Value) // call by value {} // Kopie wird uebertragen, // Aenderung wirkt sich ausserhalb // nicht aus void FuncName (int *Value) // call by reference {} // Pointer wird uebertragen, // Aenderung wirkt sich ausserhalb aus void FuncName (int Arr[]) { Arr[0] = ... } void FuncName (int Arr[][10]) { Arr[0][0] = ... } int *FuncName () { int asdf = 0; return asdf; // !Fehler! // -> Variable nach Funktionsende // nicht mehr am Stack int *asdf = (int *) malloc(sizeof(int)); *asdf = 0; return asdf; // Richtig -> Variable bleibt erhalten } // Funktionspointer int (*FuncName)(void); int (*FuncName)(int Value); int (*FuncName)(int Value, ...); FuncName pFunc = ... int (*ptr[])(const char *, ...) = { scanf, printf }; (*ptr[1])("output"); (*ptr[0])("%d",&value); // formatierte Ausgabe printf("hello world"); printf("hello \ world"); printf("%FW.GU", &value); // F ... Flags // W ... Weite // G ... Genauigkeit // U ... Formatierungszeichen // Flags: // - ... linksbündig // 0 ... mit 0en fuellen // + ... Vorzeichen ausgeben // blank ... positive Zahlen mit Leerzeichen beginnen // # ... verschiedene Bedeutung: // %#o (Oktal) 0 Präfix einfuegen // %#x (Hex) 0x Präfix einfuegen (Wert ungl. Null) // %#X (Hex) 0X Präfix einfuegen (Wert ungl. Null) // %#e Dezimalpunkt anzeigen // %#E Dezimalpunkt anzeigen // %#f Dezimalpunkt anzeigen // %#g Dezimalpunkt immer anzeigen. 0en nach dem // Dezimalpunkt werden nicht beseitigt // %#G Dezimalpunkt immer anzeigen. 0en nach dem // Dezimalpunkt werden nicht beseitigt // Formatierungszeichen: // %d, %i ... vorzeichenbehaftete ganze Dezimalzahl // %o ... vorzeichenlose ganze Oktalzahl // %u ... vorzeichenlose ganze Dezimalzahl // %x, %X ... vorzeichenlose ganze Hexzahl // (a,b,c,d,e,f) bei x; (A,B,C,D,E,F) bei X // %f ... Gleitpunktzahl (ddd.dddddd) // %e, %E ... Gleitpunktzahl (d.ddde+-dd, d.dddE+-dd) // %g, %G ... float // %c ... Zeichen // %s ... Zeichenkette // %p ... Zeigerwerte // %% ... das Zeichen % // formatiere Eingabe #include <stdio.h> nrCorrect = scanf("%d %c",&i, &c); // nrCorrect ... Nummer der korrekt eingelesenen Werte // Suchmengen %[Liste] // Zeichen welches in der Liste befindet // %[A-Z] %[a-z] %[a-fA-F] %[^Liste] // Zeichen welches nicht in der Liste befindet fflush(stdin); // Eingabe-Puffer leeren // standard Libraries // assert.h ... Fehlersuche und Debugging // ctype.h ... Zeichentest und Konvertierung // errno.h ... Fehlercodes // float.h ... Limits/Eigenschaften für Gleitpunkttypen // limits.h ... Implementierungskonstanten // locale.h ... Laenderspezifische Eigenschaften // math.h ... Mathematische Funktionen // setjmp.h ... Unbedingte Spruenge // signal.h ... Signale // stdarg.h ... Variable Parameteruebergabe // stddef.h ... Standard-Datentyp // stdio.h ... Standard-I/O // stdlib.h ... Nuetzliche Funktionen // string.h ... Zeichenkettenoperationen // time.h ... Datum und Uhrzeit // complex.h ... Komplexe Arithmetik // inttypes.h ... Fuer genauere Integer-Typen // stdbool.h ... Boolschen Datentypen // stdint.h ... Ganzzahlige Typen mit vorgegebener Breite // tgmath.h ... Generische Mathematik-Funktionen // wchar.h ... für den erweiterten Zeichensatz: // - Umwandlung von Strings zu Zahlwerten // - String- und Speicherbearbeitung // - Ein- und Ausgabe // wctype.h ... für den erweiterten Zeichensatz: // - Zeichenuntersuchung // Dateioperationen // Datenstrom oeffnen FILE *fopen(const char *pfadname, const char *modus); // r ... read // w ... write (anlegen einer Datei) // a ... write/add (falls nicht vorhanden -> NULL) // r+ ... read+write // w+ ... write (falls vorhanden -> zuvor loeschen) // a+ ... write/add (falls nicht vorhanden -> anlegen) // // b ... Binaermodus // t ... Textmodus // // stdin ... Standardeingabe // stdout ... Standardausgabe // stderr ... Standardfehlerausgabe // Datenstrom schliessen int fclose(FILE *stream); // Testet auf Dateiende im Stream int feof(FILE *stream); // Testet auf Fehler im Stream int ferror(FILE *stream); // Leert den Puffer im Datenstrom int fflush(FILE *stream); // Zeichenweise lesen vom Stream int fgetc(FILE *stream); // Zeilenweise lesen vom Stream char *fgets(char *str, int num, FILE *stream); // Position im Stream ermitteln int fgetpos(FILE *stream, fpos_t *position); // Formatierte Ausgabe an Stream int fprintf(FILE *stream, const char *format, ... ); // Zeichenweise schreiben in den Stream int fputc(int character, FILE *stream); // Schreibt einen String in den Stream int fputs(const char *str, FILE *stream); // Datenstrom erneut oeffnen FILE *freopen(const char *filename, const char *mode, FILE *stream); // Formatierte Eingabe vom Stream int fscanf(FILE *stream, const char *format, ... ); // Dateizeiger neu positionieren int fseek(FILE *stream, long int offset, int origin); // Dateizeiger neu positionieren int fsetpos(FILE *stream, const fpos_t *pos); // Position im Stream ermitteln long int ftell(FILE *stream); // Zeichenweise lesen vom Stream int getc(FILE *stream); // Zeichenweise lesen von stdin int getchar(void); // Liest String von stdin (unsichereFunktion) char *gets(char *str); // Formatierte Ausgabe an stdout int printf(const char *format, ... ); // Zeichenweise schreiben in den Stream int putc(int character, FILE *stream); // Zeichenweise schreiben an stdout int putchar(int character); // Zeichenkette an Stream stdout int puts(const char *str); // Formatierte Eingabe von stdin int scanf(const char *format, ... ); // Streampuffer einrichten void setbuf(FILE *stream, char *buffer); // Streampuffer veraendern int setvbuf(FILE *stream, char *buffer, int mode, size_t size); // Formatierte Ausgabe in einem String int sprintf(char *str, const char *format, ... ); // Formatierte Eingabe aus einem String int sscanf(const char *str, const char *format, ...); // Zeichen zurueck in den Stream int ungetc(int character, FILE *stream ); // Fehlercodes <errno.h> strerror(), perror() // EDOM ... Unzulaessiges Argument für eine // mathematische Funktion // ERANGE ... Ergebnis außerhalb des darstellbaren Bereichs // EZERO ... Fehler 0 // EINVFNC ... Ungueltige Funktionsnummer // ENOFILE ... Datei nicht gefunden // ENOPATH ... Pfad nicht gefunden // ECONTR ... Speicherbloecke zerstoert // EINVMEM ... Ungueltige Speicherblockadresse // EINVENV ... Ungueltiges Environment // EINVFMT ... Ungueltiges Format // EINVACC ... Ungueltiger Zugriffscode // EINVDAT ... Ungueltige Daten // EINVDRV ... Ungueltige Laufwerksangabe // ECURDIR ... Versuch, das aktuelle Verzeichnis zu loeschen // ENOTSAM ... Nicht das gleiche Geraet // ENMFILE ... Keine weiteren Dateien mehr // ENOENT ... Datei oder Verzeichnis existiert nicht // EMFILE ... Zu viele geoeffnete Dateien // EACCES ... Zugriff verweigert // EBADF ... Ungueltiger Datei-Deskriptor // ENOMEM ... Zu wenig Speicher // ENODEV ... Geraet existiert nicht // EINVAL ... Ungueltiges Argument // E2BIG ... Argumentliste ist zu lang // ENOEXEC ... Fehler beim Exec-Format // EXDEV ... Kreuzverbindung von Geraeten // EFAULT ... Unbekannter Fehler // EEXIST ... Datei existiert bereits