Software Entwicklung 1

Transkript

1 Software Entwicklung 1 Annette Bieniusa AG Softech FB Informatik TU Kaiserslautern

2 Einführung in C Bieniusa Software Entwicklung 1 2/ 50

3 Warum C in SE1? Meist verwendete Sprache weltweit Viele wichtige Einsatzgebiete: Systemprogrammierung, eingebettete Systeme, Numerik und Simulationen, Hochleistungsrechner Prozedurale Programmiersprache Einblick in Speichermanagement Essentiell, um auch in anderen Sprachen effizienten Code zu schreiben! Wie kann ich eine Speicheradressen direkt ansprechen? Wie werden Objekte / Daten / Arrays im Speicher verwaltet? Konzept: Pointer / Zeiger Gleiche Syntax - unterschiedliche Semantik! Bieniusa Software Entwicklung 1 3/ 50

4 Abgrenzung: C vs. C++ vs. Java Java und C++ sind C-ähnliche Sprachen C++ ist Geschwistersprache von C Erweiterung um Objekt-Orientierung Nicht vollständig kompatibel ( Typsystem) Java betont Plattformunabhängigkeit Java Virtual Machine Als sichere Sprache konzipiert Bieniusa Software Entwicklung 1 4/ 50

5 Hello World! 1 # include <stdio.h> 2 3 /* Hello - World in C */ 4 int main ( void ) // Hauptprogramm 5 { 6 printf (" Hello world!\n"); 7 return 0; 8 } Bieniusa Software Entwicklung 1 5/ 50

6 Dateien in C Programmeinheit besteht aus Quellcode-Datei (.c) und (evtl.) Header-Datei (.h) Getrennte Übersetzung der Quellcode-Dateien in Object-Dateien (.o /.obj) möglich Linker (dt. Binder) fasst Object-Dateien zu ausführbaren Programmen zusammen ( /.exe) Bieniusa Software Entwicklung 1 6/ 50

7 Compile, Link, Execute 0. Präprozessor: Vorverarbeitungsschritt, wird automatisch vom Compiler aufgerufen Präprozessor-Anweisungen sind markiert durch # z.b. Inhalt der mit #include eingebundenen Header-Dateien wird in die zu compilierende Datei kopiert 1. Compiler: ruft den Präprozessor auf Datei foo.c auf und übersetzt in eine Object-Datei foo.o: > clang -c foo.c 2. Linker: fügt mehrere Object-Dateien (foo.o, bar.o, baz.o) zu einem Programm myprog zusammen: > clang foo.o bar.o baz.o -o myprog Dieses kann dann direkt ausgeführt werden: >./myprog Bieniusa Software Entwicklung 1 7/ 50

8 Übersetzung von Programmen Falls das Programm nur aus einer Datei besteht, kann man es in einem Schritt compilieren und linken: > clang foo.c -o foo Name nach -o ist der Name für die ausführbare Datei; clang foo.c erzeugt (aus historischen Gründen) als ausführbares Programm die Datei a.out (bzw. a.exe unter Windows) Bieniusa Software Entwicklung 1 8/ 50

9 Basisdatentypen short, int, long float, double char ganzzahlige Wert Gleitkommawerte Zeichen Wertebereich ist maschinenabhängig Unterscheidung signed vs. unsigned Typen mit fester Größe int8_t, int16_t, int32_t in Header-Datei stdint.h Bieniusa Software Entwicklung 1 9/ 50

10 Boolsche Werte Keine boolschen Werte in C Vergleiche wie i > j und logische Operatoren sind vom Typ int Wert 1, falls sie wahr sind, und 0, andernfalls In Bedingungen (bei if, while, for usw.) bedeutet wahr lediglich von Null verschieden. if (Ausdruck) {...} ist äquivalent zu if ((Ausdruck)!= 0) {...} Bieniusa Software Entwicklung 1 10/ 50

11 Variablen int x; /* Deklaration ohne Initialisierung */ int y = 3; /* Deklaration mit Initialisierung */ Lokale Variablen sollten vor erster Verwendung initialisiert werden! Lesen von uninitialisierten Variablen ist undefiniert Option -Wall beim Compilieren liefert Hinweise Bieniusa Software Entwicklung 1 11/ 50

12 Frage: Was passiert bei der Ausführung dieses Programms? 1 # include <stdio.h> 2 3 int main ( void ) 4 { 5 int y = 0; 6 int x = 3/ y; 7 8 printf (" Hello world!\n"); 9 printf ("%d/n",x); 10 return 0; 11 } Bieniusa Software Entwicklung 1 12/ 50

13 Undefiniertes Verhalten in C Warnung! Permissible undefined behavior ranges from ignoring the situation completely with unpredictable results, to having demons fly out of your nose. Null Pointer Dereferenzierung (Signed) Integer Overflow Lesen von uninitialisierten Variablen Verwendung von Speicher nach Freigabe Quelle: Bieniusa Software Entwicklung 1 13/ 50

14 Funktionen Bieniusa Software Entwicklung 1 14/ 50

15 Rückgabewert und Parameter I Funktionen, die keinen Rückgabewert liefern, haben void als Rückgabetyp. Bei Funktionen, die keine Parameter nehmen, verwenden wir void anstelle der Parameterdeklaration. Enthält eine Funktionsdeklaration keinerlei Parameterinformation, wird angenommen, dass die Funktion beliebig viele Parameter nimmt. Bieniusa Software Entwicklung 1 15/ 50

16 Rückgabewert und Parameter II 1 int f( int x) { 2 return x; 3 } 4 5 int g() { 6 return 8; 7 } 8 9 int h( void ) { 0 return 3; 1 } 2 3 int main ( void ) 4 { 5 g (5) ; 6 f (5) ; 7 h (3) ; 8 return 0; 9 } $ clang noparams.c -o noparams noparams.c:15:8: warning: too many arguments in call to g g(5); ~ ^ noparams.c:17:7: error: too many arguments to function call, expected 0, have 1 h(3); ~ ^ noparams.c:17:1: note: h declared here int h(void) { ^ 1 warning and 1 error generated. Bieniusa Software Entwicklung 1 16/ 50

17 Reihenfolge von Funktionsdefinitionen Eine Funktion muss vor ihrer Verwendung deklariert werden, entweder mit Implementierung oder Funktionsprototyp. 1 # include <stdio.h> 2 3 /* Funktionsprototyp */ 4 double square ( double x); 5 6 int main ( void ) 7 { 8 double x = 2.; 9 printf ("%f %f\n", x, square (x)); 10 return 0; 11 } /* Funktionsdefinition */ 14 double square ( double x) 15 { 16 return x * x; 17 } Bieniusa Software Entwicklung 1 17/ 50

18 Lokale vs. globale Variablen 1 # include <stdio.h> 2 3 int i = 90; /* globale Variable */ 4 5 int main ( void ) 6 { 7 int j = 25; /* lokale Variable */ 8 { 9 int j = 3; /* lokale Variable */ 10 printf ("%d ",j); 11 } 12 printf ("%d ",j); 13 printf ("%d\n",i); 14 return 0; 15 } Bieniusa Software Entwicklung 1 18/ 50

19 Zeiger Bieniusa Software Entwicklung 1 19/ 50

20 Variablen Der Bezeichner erlaubt es, die Variable innerhalb ihres Gültigkeitsbereichs zu verwenden. Der aktuelle Wert kann gelesen oder durch einen anderen Wert ersetzt werden. Der Datentyp bestimmt, welche Werte eine Variable repräsentieren kann. Die Speicheradresse gibt den Ort im Speicher an, wo der Wert abgespeichert wird. Bieniusa Software Entwicklung 1 20/ 50

21 Zeiger Ein Zeiger (engl. pointer) ist ein Wert, der eine Speicheradresse bezeichnet. Ein Zeiger referenziert einen Wert, wenn dieser Wert an der entsprechenden Speicheradresse gespeichert ist. Zeiger können beliebige Datentypen, ja sogar Funktionen referenzieren. Bieniusa Software Entwicklung 1 21/ 50

22 Ermitteln der Adresse 1 # include <stdio.h> 2 3 int main ( void ) { 4 int x = 7; 5 int *y = &x; 6 *y = 10; 7 return 0; 8 } $./a.out Die Adresse von x ist 0x7fff593e77c8 Der Wert von x ist 7 $./a.out Die Adresse von x ist 0x7fff5e7987c8 Der Wert von x ist 7 $./a.out Die Adresse von x ist 0x7fff596117c8 Der Wert von x ist 7 Bieniusa Software Entwicklung 1 22/ 50

23 Deklaration von Zeigern Der Typbezeichner für einen Zeiger auf einen Wert vom Typ t ist t*. int *a, * b; // a und b Zeiger auf int int *y, x ; // y Zeiger und x int int * f, g; // f Zeiger und g int!! Bieniusa Software Entwicklung 1 23/ 50

24 Zuweisung von Zeigern Der Adressoperator & liefert einen Zeiger; d.h. eine Adresse. int x = 42; // x ist ein Integer mit Wert 42 int * p = & x; // p ist ein Zeiger auf x Bieniusa Software Entwicklung 1 24/ 50

25 NULL Der Null-Zeiger ist ein spezieller Wert, der angibt, dass ein Zeiger nicht auf eine gültige Speicheradresse verweist. int * p1 = NULL ; // Null Pointer NULL ist eine Null-Pointer-Konstante. In C99 als Integer-Wert 0 implementiert. Der Adress-Operator & liefert niemals einen Null-Zeiger. Bieniusa Software Entwicklung 1 25/ 50

26 Frage Was ist der Unterschied zwischen einem Null-Zeiger und einem nicht initialisierten Zeiger? Bieniusa Software Entwicklung 1 26/ 50

27 Dereferenzieren von Zeigern Der Wert an Adresse y wird über den Indirektionsoperator *, z.b. *y, gelesen oder auch geschrieben. 1 # import <stdio.h> 2 3 int main ( void ) 4 { 5 int x = 7; 6 int *y = &x; 7 printf (" Die Adresse von x ist %p \n", y); 8 printf (" Der Wert von x ist %d \n", *y); 9 *y = 10; 10 printf (" Der Wert von x ist jetzt % d \ n", x); return 0; 13 } Hinweis: Ein Zeiger vom Typ void* verweist auf Daten unbekannten Typs und kann nicht dereferenziert werden. Bieniusa Software Entwicklung 1 27/ 50

28 Segmentation faults Das Derefenzieren eines Zeigers, der zuvor nicht mit einer gültigen Adresse initialisiert wurde, ist undefiniert. Gefahr: Beliebiger Zugriff auf (geschützten) Speicherbereich Oft: Abbruch mit Segmentation Fault Bieniusa Software Entwicklung 1 28/ 50

29 Parameterübergabe bei Funktionen: Call-by-value void swap1 ( int x, int y) { int temp ; temp = x; /* Speichere den Wert von x in temp */ x = y; /* Speichere den Wert von y in x */ y = temp ; /* Speichere den Wert von temp in xy */ } return ; Bieniusa Software Entwicklung 1 29/ 50

30 Swap der Speicherinhalte 1 # include <stdio.h> 2 # include < stdlib.h> 3 4 void swap2 ( int *x, int * y) 5 { 6 int temp = * x; /* Speichere den Wert an x in temp */ 7 * x = * y; /* Speichere den Wert an y an x */ 8 * y = temp ; /* Speichere den Wert von temp an y */ 9 } int main ( void ) { 12 int a = 86; 13 int b = 42; 14 printf (" Vor swap : a = %d, b = %d \n", a, b); 15 swap2 (&a, &b); 16 printf (" Nach swap : a = %d, b = %d \n", a, b); 17 return 0; 18 } Bieniusa Software Entwicklung 1 30/ 50

31 Funktionen mit mehreren Ergebnissen Beispiel scanf: int i, j; j = scanf ("%d", &i); Rückgabewert: Anzahl der Zeichen, die aus dem Eingabestrom gelesen wurden Ergebnisse des Einlesens wird über Zeiger zurückgegeben Bieniusa Software Entwicklung 1 31/ 50

32 Dynamische Speicherverwaltung Bieniusa Software Entwicklung 1 32/ 50

33 Klassifizierung von Speicherbereichen I Bieniusa Software Entwicklung 1 33/ 50

34 Klassifizierung von Speicherbereichen II Bieniusa Software Entwicklung 1 34/ 50

35 Klassifizierung von Speicherbereichen III Bieniusa Software Entwicklung 1 35/ 50

36 Klassifizierung von Speicherbereichen IV Bieniusa Software Entwicklung 1 36/ 50

37 Klassifizierung von Speicherbereichen V Bieniusa Software Entwicklung 1 37/ 50

38 Dynamische Speicherverwaltung Funktion void *malloc(size_t n) alloziert n Bytes auf dem Heap; liefert Zeiger auf den Beginn des alloziertes Speicherbereichs oder NULL Funktion void free(void *pointer) gibt Speicher wieder frei (verhindert Speicherlecks) Zugriff auf freigegebenen Speicher, mehrmaliges Freigeben des gleichen Speicherbereichs, Zugriff auf nicht-initialisierten Speicher... ist undefiniert! int *p = malloc (10 * sizeof ( int )); if (p == NULL ) {... /* Problembehandlung */ } else { /* Speicherbereich kann verwendet werden */... } /* Freigeben */ free (p); Bieniusa Software Entwicklung 1 38/ 50

39 sizeof - Operator sizeof liefert die jeweils notwendige Größe des Speicherbereichs in Byte Portierbarkeit von Programmen auf verschiedene Systeme 1 # include <stdio.h> 2 3 int main ( void ) { 4 printf (" char : %ld Byte \n", sizeof ( char )); 5 printf (" int : %ld Bytes \n", sizeof ( int )); 6 printf (" long : %ld Bytes \n", sizeof ( long int )); 7 printf (" float : %ld Bytes \n", sizeof ( float )); 8 printf (" double : %ld Bytes \n", sizeof ( double )); 9 return 0; 10 } Bieniusa Software Entwicklung 1 39/ 50

40 Zugriff auf Elemente im allozierten Speicherbereich int *p = malloc (3 * sizeof ( int )); *(p+0) = 1; *(p+1) = 3; *(p+2) = 7; Bieniusa Software Entwicklung 1 40/ 50

41 Arrays Zusammenfassen und Verwalten von verwandten Daten gleichen Typs unter einem Namen. Diese Daten sind angeordnet und können durch einen Index addressiert werden (0, 1,..., n 1). Allokation auf dem Stack: int a [6]; // Array mit Namen a mit 6 Integern int b [6] = {0,0,1,0,0,0}; // Deklaration und Initialisierung Allokation auf dem Heap: int * ar; ar = ( int *) malloc ( sizeof ( int ) * 10) ; if (ar == NULL ) { printf (" Nicht genug Speicher vorhanden."); // Fehler ausgeben exit (1) ; // Programm mit Fehlercode abbrechen } free ( ar); // gibt Speicher wieder frei Bieniusa Software Entwicklung 1 41/ 50

42 Initialisieren von Arrays Der Inhalt von Arrays muss vor dem ersten Lesezugriff initialisiert werden. for ( int i = 0; i < 6; i ++) { a[ i] = 2 * i; } Bieniusa Software Entwicklung 1 42/ 50

43 Zugriff außerhalb der Array-Grenzen /* Weiterfuehrung des Beispiels */ printf ("%d",a [ -1]) ; printf ("%d",a [6]) ; Verhalten ist undefiniert! Bieniusa Software Entwicklung 1 43/ 50

44 Adressarithmetik auf Arrays I Zwischen Arrays und Zeigern besteht in C ein enger Zusammenhang: Jede Operation mit Array-Indizes kann man auch mit Zeigern formulieren. Beispiel: a ist Array mit 6 int-elementen. Im Speicher realisiert als ein Block von 6 aufeinanderfolgenden Elementen. Deklariert man nun eine Variable pa als Zeiger auf einen int-wert: int *pa; dann kann pa auf das Element an Position 0 von a verweisen; pa = &a [0]; pa enthält die Adresse von a[0]. &a[0] ist äquivalent zu a. Bieniusa Software Entwicklung 1 44/ 50

45 Adressarithmetik auf Arrays II Die Zuweisung x = *pa; kopiert den Wert von a[0] nach x. Die Adresse des Elements a[i] ist gegeben durch pa + i; und *(pa + i) liefert den Wert des Elements a[i]. Bieniusa Software Entwicklung 1 45/ 50

46 Arrays sind keine Zeiger-Variablen! Arrays kann man keinen Wert zuweisen; einer Zeiger-Variablen kann man hingegen eine andere Speicheradresse zuweisen. Für Arrays kann man die Größe (in byte) über sizeof ermitteln. Bieniusa Software Entwicklung 1 46/ 50

47 Arrays als Parameter Wird ein Array als Parameter an eine Funktion übergeben, so wird tatsächlich die Adresse des Anfangselements, also ein Zeiger, übergeben. Wie viele Elemente sind in dem Array? Unbekannt! Mitverwalten eines weiteren Parameters mit der Größe Beispiel: Kommandozeilenparameter 1 # include <stdio.h> 2 3 int main ( int argc, char * argv []) 4 { 5 // Ausgabe der Kommandozeilenparameter 6 for ( int i = 0; i < argc ; i ++) { 7 printf (" argv [%d] = %s \n", i, argv [i]); 8 } 9 return 0; 10 } Bieniusa Software Entwicklung 1 47/ 50

48 Präzedenz von * Der Ausdruck *(pa + 1) liefert Bieniusa Software Entwicklung 1 48/ 50

49 Präzedenz von * Der Ausdruck *(pa + 1) liefert den Wert an Adresse pa mit Abstand 1. Der Ausdruck *pa + 1 liefert Bieniusa Software Entwicklung 1 48/ 50

50 Präzedenz von * Der Ausdruck *(pa + 1) liefert den Wert an Adresse pa mit Abstand 1. Der Ausdruck *pa + 1 liefert den Wert an Adresse pa und addiert zu diesem Wert 1. Bieniusa Software Entwicklung 1 48/ 50

51 Variante: calloc Die Variante void *calloc(size_t n, size_t elementsize) alloziert einen Speicherbereich der Größe n elementsize und initialisert ihn mit 0. /* Speicherplatz fuer 200 chars */ char *w = calloc (200, sizeof ( char )); /* Speicherplatz fuer 10 int */ int *p = calloc (10, sizeof ( int )); Bieniusa Software Entwicklung 1 49/ 50

52 Variante: realloc Die Funktion void *realloc(void *pointer, size_t size) erlaubt es, die Größe von Speicherbereichen zu erweitern bzw. zu verkleinern. int *p = ( int *) malloc ( initial_size );... void * tmp = realloc (p, bigger_ size ); if ( tmp!= NULL ) { p = tmp ; /* OK */ } else { /* Problembehandlung */... } Bieniusa Software Entwicklung 1 50/ 50