OSUE Einführung in C. Denise Ratasich. März /60. basierend auf Slides von Roland Kammerer, Bernhard Frömel

Transkript

1 1/60 Denise Ratasich basierend auf Slides von Roland Kammerer, Bernhard Frömel Institut für Technische Informatik Technische Universität Wien Betriebssysteme UE SS16 März 2016

2 2/60 Einleitung Historisches Warum C? Standards Erste Schritte Teil I Einleitung

3 3/60 Historisches Einleitung Historisches Warum C? Standards Erste Schritte 1964: MIT, General Electrics, Bell Labs und AT&T wollten neues Betriebssystem entwickeln (Multics) 1969: Zu teuer Bell Labs steigt aus Gruppe um Ken Thompson (Bell Labs) sucht Alternativen zu Multics und will das System in Assemblersprache entwickeln nicht portabel zeitaufwändig fehleranfällig ldi r16, 0xFF out DDRC, r16 ldi r16, 0x00 out PORTC, r16 Alternativen zur Assemblersprache wurden gesucht. C entwickelte sich als Nachfolger der Sprache B, ALGOL (ALGOrithmic Language)

4 4/60 Warum C? Einleitung Historisches Warum C? Standards Erste Schritte Früher: Heute: Portabilität Erweiterbarkeit durch Libraries Performance (vgl. Betriebssystem-Kernel: Windows, Linux, BSDs,... ) Viele Libraries vorhanden Hardwarenahe Programmierung Computergraphik, Spiele Auch moderne Interpreter in C geschrieben (Python, Perl, Ruby,... ) Viele Generatoren erzeugen C-Code (z.b. Matlab/Simulink)

5 Einleitung Historisches Warum C? Standards Erste Schritte Standards 1978: Quasistandard durch Ritchie und Kernighan im Buch The C Programming Language 1989: ANSI-C bzw. C : C-99 Nicht von allen Compilern implementiert Nicht einmal gcc unterstützt ihn vollständig Der für verwendete Standard 2011: C-11 $ gcc std=c99 pedantic Wall D_XOPEN_SOURCE=500 \ D_BSD_SOURCE g c filename. c heute: Neuer Quasistandard (zumindest in der Free/OpenSource Welt) durch gcc 1 und gnu extensions Wobei selbst gnu-extensions teilweise nur informell spezifiziert sind LLVM/clang 1 5/60

6 6/60 Hello, C World Einleitung Historisches Warum C? Standards Erste Schritte #include <stdio.h> int main(void) { (void) printf("hello, C World\n"); } return 0;

7 7/60 Einleitung Historisches Warum C? Standards Erste Schritte Kompiliervorgang Source Code muss in Maschinensprache übersetzt werden Code Präprozessor Compiler Linker $ gcc o prog prog. c # a l l e s in einem S c h r i t t $. / prog # Programm starten Einzelschritte (fyi only): Präprozessor: $ gcc E prog. c [.. ] extern i n t p r i n t f ( const char r e s t r i c t format,... ) ; [.. ] Compiler, Linker: $ gcc v o prog prog. c [.. ] <.. >/ cc1 [.. ] prog. c [.. ] o /tmp/ccpmj9ab. s [.. ] as V Qy o /tmp/ccdr6ueb. o /tmp/ccpmj9ab. s [.. ] <.. >/ c ollect2 [.. ] o prog [.. ] crtn. o

8 8/60 Kommentare Einleitung Historisches Warum C? Standards Erste Schritte /* Ich bin ein Kommentar in C-89 */ // Ich einer aus dem C-99-Standard // Ich ende immer am Zeilenende /* mehrere Zeilen sind okay */ Code kommentieren (Funktionen, etc.) strukturieren (einrücken, Zeilenumbrüche, etc.)

9 9/60 Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Teil II Variablen &

10 10/60 Definition Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Für Variablen muss Speicherplatz reserviert werden (je nach Datentyp) Name wird festgelegt Das passiert bei der Definition Definition darf nur einmal im Code vorkommen int i; /* Integer Variable i, + Definition */

11 11/60 Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Variablen haben einen Typ Dieser Typ muss dem Compiler bekannt gemacht werden Bekanntgabe bei der extern int j; /*, Definition wo anders */ darf mehrmals vorkommen Nicht jede ist eine Definition Jede Definition ist eine Oft wird zwischen und Definition nicht unterschieden Es wird für beides der Begriff verwendet

12 12/60 Initialisierung Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Nachdem eine Variable einen Speicherplatz hat, ist der anfängliche Inhalt noch undefiniert (oder wurde schon zur Compilezeit in einen vorinitialisierten Speicherbereich gelegt) Initialisierung weist der Variablen einen Wert zu Zuweisung erfolgt mit = int k = 23; /* hier mit Initialisierung */

13 13/60 Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren int i; int i, j, k; int i, j = 23, k = 42; /* Korrekt, schlechter Stil */ int i, char b; /* Fehler */ int i; char b; /* Korrekt */

14 14/60 Byte im C99 Standard Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren A byte is composed of a contiguous sequence of bits, the number of which is implementation-defined. ISO/IEC 9899:TC3, Committee Draft September 7, 2007

15 15/60 Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Ganze Zahlen char: 1 Byte (Byte muss laut Standard nicht 8 Bit lang sein). Wird oft zum Speichern von Zeichen und Strings verwendet short int: Mindestens 16 Bit int: natürliche Größe, meist 32 oder 64 Bit long int: Mindestens 32 Bit long long int: Mindestens 64 Bit. Erst ab C-99. Tatsächliche Größe in <limits.h> ersichtlich Mit C-99 wurden standardisierte Typen eingeführt (<stdint.h>): z.b., uint32_t, int8_t,... Es gibt vorzeichenlose und vorzeichenbehaftete Varianten (zb. signed int, unsigned int) Literale können hexadezimal (0x als präfix) und oktal (0 als präfix) angegeben werden (zb: 0x8, 024)

16 16/60 Fließkommazahlen Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren float: einfache Genauigkeit double: doppelte Genauigkeit long double: erweiterte Genauigkeit Über die interne Darstellung wird im Standard keine Aussage getroffen Kein Unterschied zwischen vorzeichenbehaftet und vorzeichenlos immer vorzeichenbehaftet

17 17/60 Wertebereich Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Ob eine Variable vorzeichenbehaftet oder vorzeichenlos verwendet wird, entscheidet über ihren Wertebereich. Die gezeigten Wertebereiche sind nicht im Standard spezifiziert, sie dienen der Veranschaulichung. Type signed unsigned char -128 bis bis 255 short int bis bis long int bis 0 bis

18 18/60 sizeof Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Der Operator sizeof wird zur Ermittelung des Speicherbedarfs verwendet int i; (void) printf("%lu Byte(s)\n", sizeof i); (void) printf("%lu Byte(s)\n", sizeof (int));

19 19/60 Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren #define MYCONST (23) /* oder */ const int i = 23; MYCONST wird vom Präprozessor ersetzt. Erklärung des Präprozessors folgt später const definiert eine typisierte Konstante im Code. Darf/Kann nicht geändert werden

20 20/60 Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Scope Vor C-99 mussten Variablen am Anfang eines Blocks deklariert werden Variablen sind innerhalb ihres Blocks sichtbar #include <stdio.h> int main(void) { int i = 23, j = 42; { int i; i = 2323; (void) printf("%d, ", i); (void) printf("%d, ", j); } (void) printf("%d\n", i); return 0; } $ 2323, 42, 23

21 21/60 C99 Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren #include <stdio.h> int main(void) { /* i, j nicht am anfang eines blocks */ for (int i = 0; i < 10; ++i) { (void) printf("%d\n", i); int j = 23; (void) printf("%d\n", j); } return 0; }

22 22/60 static Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren static weist einer Variablen einen festen Speicherplatz zu. Sie behält dadurch ihren Zustand Auf eine statische Variable kann von außen (Block oder Datei) nicht zugegriffen werden #include <stdio.h> void foo() { static int i = 23; (void) printf("%d, ", i); i = i + 1; } int main(void) { foo(); foo(); foo(); return 0; } $ 23, 24, 25,

23 23/60 extern Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Deklariert Variablen, die in einer anderen Datei definiert inc.c sind int g_variable = 1; [..] g_variable++; [..] dec.c extern int g_variable; [..] g_variable--; [..]

24 Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren volatile Variable kann sich außerhalb des Programmkontexts ändern Wichtig für hardwarenahe Programmierung (z.b. Interrupthandler, die Inhalt einer Variablen ändern) (fyi only:) Umsetzung von volatile leider Compiler-abhängig, saubere Lösungen verwenden Memory Barriers 2 volatile char keypressed = ; long count = 0; while (keypressed!= x ) { ++count; } Ohne volatile würde der Compiler die while-schleife zu while(1) optimieren, da sich aus seiner Sicht keypressed nicht ändern kann /60

25 25/60 Beispiel Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren extern const volatile unsigned long int rt_clk; Eine long int Variable ohne Vorzeichen, deren Inhalt man nicht zuweisen kann (von der man aber lesen kann), deren Inhalt sich außerhalb des Programmkontexts ändern kann, die an einer anderen Stelle definiert wird

26 26/60 Increment/Decrement Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Mit ++ und -- können Variablen um eins erhöht bzw. vermindert werden Präfix (++i) und postfix (i++) sind möglich: Präfix Operator in/dekrementiert, gibt neuen Wert zurück Postfix Operator in/dekrementiert, gibt alten Wert zurück Nach Möglichkeit präfix verwenden (auch im Hinblick auf C++) int n; int m = 0; n = ++m; $ n = 1, m = 1 int n; int m = 0; n = m++; $ n = 0, m = 1

27 Rangfolge/Assoziativität 3 Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren c = sizeof (x) + ++a / 3; c = (sizeof (x) + ((++a) / 3)); a = 5 / 2 * 3; a = (5 / 2) * 3; /* links nach rechts */ i = 3; a = i + i++; /* i == 4, a ==? (laut Standard implementierungsabhaengig!) */ i = 2; a = i i; /*??? */ 3 man operator 27/60

28 28/60 Vergleichsoperatoren & Logische Operatoren Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Operator Bedeutung < kleiner als > größer als <= kleiner oder gleich >= größer oder gleich!= ungleich == gleich && logisches und logisches oder! Negation und && werden short circuit ausgewertet

29 29/60 Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren Bitweise Operatoren Operator Bedeutung & und oder exklusives oder (xor) Einerkomplement >> Rechs-Shift << Links-Shift x: y: x & y: Für bitweise und arithmetische Operatoren existieren die Versionen Op= (z.b. i += 5 gleichbedeutend mit i = i + 5;)

30 30/60 Shift Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren << und >> zum bitweisen shiften unsigned char i = 7; /* */ i <<= 1; /* */ printf("%d\n", i); /* 14 */ printf("%d\n", 1 << 7); /* 128 == 2 hoch 7 */ Bei vorzeichenbehafteten Variablen mit negativem Wert ist das Verhalten undefiniert. int i = -7; i <<= 1; printf("%d\n", i); /* -14??? undefiniert */

31 31/60 Variablen & Definition Initialisierung Typen Scope Modifikatoren Operatoren unsigned char a, b, c; a = 4; b = 2; /* binär: a = 100, b = 010 */ c = a b; /* c = 6 */ b = a & c; /* b = 4 */ a += 3; /* a = a + 3 = 7 */ b %= 3; /* b = b % 3 = 1 (%.. modulo div) */ b = 0; if ( (b > 0) && ( (a / b) > 5) ) /*... */

32 32/60 Strukturen zur Kontrolle if switch for while/do-while continue/break Teil III Strukturen zur Kontrolle

33 33/60 if Strukturen zur Kontrolle if switch for while/do-while continue/break if (expression) statement else if (expression) statement else if (expression) statement /*... */ else statement In C gilt: 0 ist false, alles andere ist true (z.b. auch -1) Ratschlag: Nie auf die Klammerung von statement-blöcken vergessen/verzichten. Am besten auch einzeilige Statements in {} einschließen

34 Strukturen zur Kontrolle if switch for while/do-while continue/break goto fail; goto fail; Apple s libsecurity_ssl, sslkeyexchange.c: SSLVerifySignedServerKeyExchange (.. ).. i f ( ( err = SSLHashSHA1. update(&hashctx, &signedparams ) )!= 0) goto f a i l ; goto f a i l ; i f ( ( err = SSLHashSHA1. f i n a l (&hashctx, &hashout ) )!= 0) goto f a i l ;.. f a i l : SSLFreeBuffer(&signedHashes ) ; SSLFreeBuffer(&hashCtx ) ; return err ; Quellen: Security-55471/libsecurity_ssl/lib/sslKeyExchange.c 10_9_2_ssl/ Dank an Roland Kammerer für dieses Fall-Beispiel! 34/60

35 35/60 goto fail; goto fail; Strukturen zur Kontrolle if switch for while/do-while continue/break

36 Strukturen zur Kontrolle if switch for while/do-while continue/break goto fail; goto fail; Bitte auf Verwendung von goto in den regulären n verzichten. Negativbeispiel: #include <stdio.h> int main(void) { int i = 0; loopstart: ++i; if(i >= 5) goto printnum; contloop: if (i < 9) goto loopstart; goto end; printnum: (void) printf("i is %d\n", i); goto contloop; end: return 0; } 36/60

37 37/60 switch Strukturen zur Kontrolle if switch for while/do-while continue/break switch (expression) { case const-expr: statements case const-expr: statements /*... */ default: statements } Es dürfen nur als Vergleichswert verwendet werden Man sollte einen case immer mit break abschließen, sonst rutscht man in den nächsten case (siehe am Ende) Es sollte immer ein default case vorhanden sein

38 38/60 for Strukturen zur Kontrolle if switch for while/do-while continue/break for (expression1; expression2; expression3) statement Alle drei Expressions sind optional. Normalfall: expression1: Initialisierung des Zählers expression2: Überprüfung ob die Schleife fortgesetzt werden soll expression3: Den Zähler erhöhen

39 39/60 while/do-while Strukturen zur Kontrolle if switch for while/do-while continue/break while (expression) statement do statement while (expression); Bei do-while wird statement zumindest einmal ausgeführt

40 40/60 continue/break Strukturen zur Kontrolle if switch for while/do-while continue/break continue setzt beim nächsten Schleifendurchlauf der innersten Schleife fort for-schleife: expression3 wird ausgeführt, expression2 wird überprüft break verläßt die innerste Schleife und setzt nach ihr fort for-schleife: expression3 wird nicht mehr ausgeführt

41 41/60 Strukturen zur Kontrolle if switch for while/do-while continue/break int i; for (i = 0; i < 10; ++i) { (void) printf("hallo\n"); } switch (input) { case a : case A : (void) printf("a oder A\n"); break; default: (void) printf("fehler"); break; } i = 23; if (i == 42) { (void) printf("i ist 42\n"); }

42 42/60 Arrays Eindimensional Mehrdimensional Initialisierung Strings Teil IV Arrays

43 43/60 Eindimensional Arrays Eindimensional Mehrdimensional Initialisierung Strings Arrays werden zum Zusammenfassen von verwandten Werten gleichen Typs verwendet Typ Name[Größe]; int myarray[8]; myarray bietet Platz für 8 Integer Variablen Index von 0 bis 7 myarray[8] out-of-bounds

44 44/60 Mehrdimensional Arrays Eindimensional Mehrdimensional Initialisierung Strings Arrays können mehrere Dimensionen haben In C eigentlich syntactic sugar int myarray[2][3]; int myarray2[2][3][4];

45 45/60 Initialisierung Arrays Eindimensional Mehrdimensional Initialisierung Strings int myarr[2][3]= { {1,2,3}, {4,5,6}, }; int myarr2[2][3] = {1,2,3,4,5,6}; /* erste Version ist vorzuziehen */ int myarr3[] = {1, 2, 3, 4}; /* bei vollständiger Initialisierung kann die Größe weggelassen werden */

46 46/60 Strings Arrays Eindimensional Mehrdimensional Initialisierung Strings Strings sind in C Arrays von Zeichen (chars) Strings sind per Definition immer \0 terminiert. Essentiell für Funktionen die mit Strings arbeiten. Sie erkennen so das Ende eines Strings char string[] = "hallo, welt"; /* string is auto \0 terminated */ char s[6]; s[0] = h ; s[1] = a ; s[2] = l ; s[3] = l ; s[4] = o ; s[5] = \0 ; char str[] = { f, o, o, b, a, r, \0 }; (void) printf("%s\n", s); /* prints "hallo" */ s[3] = \0 ; (void) printf("%s\n", s); /* prints "hal" */

47 47/60 Funktionen Definition Globale und lokale Variablen Teil V Funktionen

48 48/60 Funktionen Definition Globale und lokale Variablen Definition von Funktionen Rückgabetyp Funktionsname(Parameterliste) { Anweisungen } Dienen der Lesbarkeit, Wiederverwendbarkeit und Wartbarkeit Müssen vor ihrer Verwendung bekannt gemacht werden int add(int a, int b) { return a + b; } int main(void) { int i; i = add(2, 3); /* i == 5 */ return 0; }

49 49/60 Funktionen Definition Globale und lokale Variablen Prototypen Wie bei Variablen wird zwischen Definition und unterschieden Ein Prototyp stellt eine dar und wird mit ; abgeschlossen /* Prototyp */ int add(int a, int b); /* int add(int x, int v); genau so gültig */ /* int add(int, int); ebenfalls OK */ /* int add(double, int); Falsch, später anderer Typ */ int main(void) { int i; i = add(2, 3); /* i == 5 */ return 0; } /* jetzt darf add nach dem Aufruf definiert werden */ int add(int a, int b) { return a + b; }

50 50/60 Global vs. lokal Funktionen Definition Globale und lokale Variablen Lokale Variablen sind nach dem Verlassen ihrer Funktion/ihres Blocks nicht mehr sichtbar Globale Variablen (außerhalb von Funktionen deklariert, meist am Anfang des Sourcecodes) behalten ihre Gültigkeit bis zum Ende des Programms Lokale Variablen überdecken globale Variablen Lokale Variablen beinhalten beim Deklarieren einen zufälligen Wert Globale Variablen werden in einen Speicherbereich abgelegt der mit 0 initialisiert ist

51 51/60 Funktionen Definition Globale und lokale Variablen int i; int j = 23; void foo() { int j = 42; (void) printf("%d\n", j); /* 42 */ } int main(void) { int k; (void) printf("%d\n", j); /* 23 */ foo(); (void) printf("%d\n", i); /* 0 */ (void) printf("%d\n", k); /* 1863 (zufällig) */ return 0; }

52 52/60 Pointer Allgemeines Speicherlayout Arithmetik man-pages Gefahren Teil VI Pointer

53 53/60 Allgemeines Pointer Allgemeines Speicherlayout Arithmetik man-pages Gefahren In C müssen Variableninhalte nicht über ihren Namen angesprochen werden Dies kann auch mit Pointern geschehen Pointer sind keine black magic, sie sind Variablen wie andere Variablen auch Unterschied: In ihnen ist eine Adresse gespeichert Wichtig für hardwarenahe Programmierung (Geschwindigkeitsvorteil) Leider auch extrem fehleranfällig Aber die coolen neuen Sprachen haben gar keine Pointer!! : Falsch, sie verstecken sie nur vor dem Programmierer/der Programmiererin

54 54/60 Pointer Allgemeines Speicherlayout Arithmetik man-pages Gefahren Pointer werden mit Typ *name deklariert Es wird nicht Speicher für eine Variable des Typs Typ alloziert, sondern ein Speicherbereich für den Typ Typ *, in dem eine Adresse gespeichert werden kann. Auf den Inhalt auf den ein Pointer zeigt, greift man mit dem Dereferenzierungsoperator * zu Auf die Adresse einer Variable greift man mit dem Adressoperator & zu int *p; /* ich bin ein pointer */ int* q; /* ich auch */ int* a, b; /* a ist ein pointer b aber _nicht_ */ int *a, b; /* a ja, b nein */ int *a, *b; /* a und b sind Pointer */

55 55/60 Pointer Allgemeines Speicherlayout Arithmetik man-pages Gefahren Speicherlayout int *a; int b = 17; a = &b; (void) printf("inhalt b: %d\n", b); /* 17 */ (void) printf("adresse b: %p\n", &b); /* 1462 */ (void) printf("inhalt a: %p\n", a); /* 1462 */ (void) printf("inhalt auf den a zeigt: %d\n", *a); /* 17 */ (void) printf("adresse von a: %p\n", &a); /* 874 */

56 56/60 Einfache Pointerarithmetik Pointer Allgemeines Speicherlayout Arithmetik man-pages Gefahren int ar[5] = {1, 2, 3, 4, 5}; int *p; p = &ar[0]; /* oder */ p = ar; /* ar ist kein Pointer, nur die Adresse! */ (void) printf("%d\n", *p); /* 1 */ *p += 22; (void) printf("%d\n", ar[0]); /* 23 */ p += 1; /* Pointer zeigt auf das naechste Element */ (void) printf("%d\n", *p); /* 2 */

57 57/60 Pointer und man Pointer Allgemeines Speicherlayout Arithmetik man-pages Gefahren $ man strcpy /* Ausgabe von "man strcpy" */ char *strcpy(char *dest, const char *src); /* mein C Code */ char *mysrc = "mystring"; char *mydest = /* momentan egal. Annahme: es ist genug Speicher vorhanden*/ (void) strcpy(mydest, mysrc); /*? */ /* oder doch eher */ (void) strcpy(*mydest, *mysrc); /*? */ man-page liest man so: strcpy will Variablen in denen Adressen stehen (*dest, *src). Wo steht die Adresse? In den Pointern, also muss man sie nicht dereferenzieren. (void) strcpy(mydest, mysrc)

58 Gefahren von Pointern Pointer Allgemeines Speicherlayout Arithmetik man-pages Gefahren Pointerarithmetik kann gefährlich werden wenn man nicht mit der nötigen Sorgfalt arbeitet Achtung: Null-Pointer-Dereferencing war 2009 das häufigste Sicherheitsproblem bei Red Hat 4 int ar[5] = {1, 2, 3, 4, 5}; int *p = &ar[0]; /* so sicher nicht! */ p += 23; /* möglicherweise ein Problem */ (void) printf("%d\n", *p); /* FAIL */ p = NULL; (void) printf("%d\n", *p); /* FAIL */ /60

59 59/60 Material Teil VII Material

60 60/60 Material Material C Programming Language - Kernighan & Ritchie Ausblick Präprozessor, Makros typedefs, structs, unions, casts, inline, void Speicherlayout, Alignment modulare Programmierung (extern, Header Dateien,... ) Funktionen und Pointer (als Argumente und return-wert), Funktionspointer