INE1 Arrays, Zeiger, Datenstrukturen

Transkript

1 INE1 Arrays, Zeiger, Datenstrukturen Arrays Felder von Elementen gleichen Typs Verwenden von Adressen: Zeiger Datenstrukturen mit struct Zeiger auf Datenstrukturen Spezielle Zeiger und komplexe Deklarationen

2 Datentypen Übersicht 2 von 50

3 Arrays Felder von Elementen gleichen Typs 3 von 50

4 Beispiel Aufgabe: Es soll eine Zahlenreihe eingelesen werden Für solche Zwecke gibt es eine spezielle Datenstruktur: Das Array Ein Array (auch Datenfeld genannt) ist eine homogene Datenstruktur, die aus mehreren Elementen des gleichen Datentyps besteht Die Elemente werden durch den Variablennamen und einen Index bestimmt (der Index ist eine ganze Zahl) 4 von 50

5 Definition int a [10]; a ist ein Array mit 10 Elementen vom Typ int Es wird Platz für 10 int-elemente reserviert Aber: Die Elemente erhalten keine Default-Werte! 5 von 50

6 Beispiele double zahlen[300]; /* 300 double-objekte zahlen[0].. zahlen[299] */ char text[20]; /* 20 Zeichen text[0].. text[19] */ Was fällt auf? 6 von 50

7 Hinweise Array-Grenzen beginnen immer bei 0 int werte[5]; Das letzte Element dieses Arrays ist werte[4] werte[3] = 5; werte[2] = werte[4] + werte[0]; index = 1; werte[index] = 233; 7 von 50

8 Hinweise Es findet keine Bereichsüberprüfung statt (weder zur Übersetzungs- noch zur Laufzeit) Mit anderen Worten: Es wird nicht geprüft, ob der Zugriff auf ein Arrayelement wirklich innerhalb des Arrays liegt! int a[5]; a[3] = 4; a[8] = 222; /* Keine Fehlermeldung zur Laufzeit!!! */ a[-3] = 36; /* Keine Fehlermeldung zur Laufzeit!!! */ /* Aber Folgefehler wahrscheinlich */ 8 von 50

9 Initialisierung Arrays können bei der Definition auch gleich initialisiert werden int a[5] = {4,7,12,77,2}; /* Alle 5 Elemente werden initialisiert */ int b[] = {4,7,12,77,2}; /* Länge wird implizit auf 5 gesetzt */ int c[5] = {4,3,88,5}; /* OK, letztes Element erhält Wert 0 */ int d[9] = {0}; /* Alle Elemente 0 */ int d[5] = {4,3,88,5,3,6}; /* Kompilierfehler */ 9 von 50

10 Zuweisung? Das Füllen des Arrays mit {...} funktioniert nur bei der Deklaration der Variablen Folgendes gibt einen Kompilierfehler: int a[5]; a = {1, 3, 66, 34, 7}; /* Fehler */ Die Grösse eines Arrays kann nach der Deklaration nicht mehr verändert werden 10 von 50

11 Grösse von Arrays Normalerweise: Konstante Grösse erforderlich Bei älteren Compiler Versionen muss die Konstanten mit #define festgelegt werden. const int KONSTANTE= 5; #define ALT_KONSTANTE 4 Achtung Achtung kein kein ";" ";" int a[3]; /* kein Problem */ int b[alt_konstante ]; /* kein Problem: nur Textersetzung */ int c[konstante]; /* geht ab C99 */ int foo (int nichtkonstant) { int c[konstante]; /* geht ab C99 */ int d[konstante+ 4]; /* Compiler kann dies auswerten */ int e[nichtkonstant]; /* geht ab C99 Array auf Stack */ } 11 von 50

12 Beispiele const int MAXZ = 300; double zahlen[maxz]; /* 300 double-werte zahlen[0].. zahlen[299] */ char text[20]; /* 20 Buchstaben text[0].. text[19] */ for (i = 0; i < MAXZ; i++) { } zahlen[i] = i; /* Zuweisung in einer Schleife */ text[4] = 'c'; 12 von 50

13 Verwenden von Adressen: Zeiger 13 von 50

14 Zeiger Bisher: Zugriff erfolgte immer direkt auf die Variablen; ohne Berücksichtigung wo (unter welcher Adresse) diese Variable im Speicher abgelegt ist In C/C++ arbeitet man häufig mit den Adressen von Variablen: Dazu existieren in C/C++ die Zeiger (engl. Pointer) Ein Zeiger ist eine Variable, welche die Adresse einer andern Variablen enthält Wenn der Zeiger die Adresse einer anderen Variable enthält, sagt man, dass der Pointer auf diese Variable zeigt 14 von 50

15 Zeiger Ein Zeiger enthält somit die Adresse auf den eigentlichen Wert Greift man über den Zeiger auf die Variable zu, wird der Zeiger dereferenziert px px von 50

16 Zeiger definieren Beispiel Konvention Konvention mit mit einem einem "p" "p" beginnen beginnen int *px; /* Zeiger auf int */ char *pc; /* Zeiger auf char */ Zeiger zeigt auf Daten von einem bestimmten Typ 16 von 50

17 Der Zeiger muss gesetzt werden 1000 int anzahl; int *panzahl; /* Adresse von anzahl zuweisen */ panzahl = &anzahl; /* Über Zeiger zugreifen: */ *panzahl = 77; panzahl anzahl C C C von 50

18 Zeiger und Adressoperationen Adressoperator & liefert Adresse eines Objekts Dereferenzierungsoperator * greift auf das Objekt zu, auf das der Zeiger zeigt & * Bei scanf schon verwendet scanf("%lf",&value); Damit Damit scanf scanf weiss, weiss, wohin wohin der der Wert Wert gespeichert gespeichert werden werden soll, soll, muss muss der der Speicherort Speicherort (=Adresse (=Adresse der der Variablen) Variablen) übergeben übergeben werden werden 18 von 50

19 Zeigerarithmetik und Arrays int a[10]; int *pa; pa = &a[0]; pa a a[0] a[1] von 50

20 Zeigerarithmetik und Arrays Zeigerarithmetik statt Arrayzugriff int a[10]; int *pa = &a[0]; a[3] = 42; // a[3] den Wert 42 zuweisen *(pa+3) = 42; // a[3] den Wert 42 zuweisen pa pa+3 a 4 20 von 50

21 Zeigerarithmetik und Arrays Mit Zeigern kann gerechnet werden Bsp: pa + 4, pa++, pa-- int a[10]; int *pa = &a[0]; a[3] = 42 ; *(pa + 3) = 42 ; /* gleich wie a[3]=42; */ pa = pa + 3; /* pa ist variabel */ *pa = 42 ; /* gleich wie a[3]=42; */ 21 von 50

22 Zeigerarithmetik und Arrays Da zu jedem Zeiger ein Datentyp gehört, wird bei Operationen auf Zeiger die Grösse des Datentyps berücksichtigt double a[10]; double *pa = &a[0]; a[3] = 42.0 ; *(pa + 3) = 42.0 ; /* gleich wie a[3]=42; */ pa = pa + 3; /* pa ist variabel */ *pa = 42.0 ; /* gleich wie a[3]=42; */ pa pa+3 a 8 22 von 50

23 Zuweisen von Zeigervariablen int x[4] = { 1, 2, 3, 4 }; int *px = &x[0]; int *py = px; printf("%d",*px); // 1 *py = 5; printf("%d",*px); // 5 px px py py Wenn Zeigervariablen Werte zugewiesen (kopiert) werden, dann werden nur die Zeiger (aber nicht die Werte auf diese) kopiert. Man erhält lediglich zwei "Zugriffspfade" auf dieselben Daten Wenn Werte über py verändert werden sind sie auch über px verändert 23 von 50

24 Typischer Fehler int *px; *px = 25; In der zweiten Zeile wird irgendeine Stelle im Speicher mit 25 überschrieben! Zeigervariablen mit unkorrekten Werten führen - im besseren Fall- zu Laufzeitfehlern wie Bustrap-Error, Segment-Violation, Memory-Violation oder gar zum System-Crash Im schlechtesten Fall zeigt der Zeiger in einen gültigen Speicherbereich, das Programm läuft aber es wird irgendwo (!) Speicher überschrieben Unbestimmtes Verhalten (bei jedem Programmstart wieder anders), plötzlich veränderte Werte in andern Variablen, die NICHTS mit dem eigenen Programm zu tun haben. Sog. DANGLING POINTER - DER ABSOLUT SCHLIMMSTE FEHLER IN DER PROGRAMMIERUNG ÜBERHAUPT 24 von 50

25 NULL Wenn ein Zeiger auf nichts zeigen soll, wird ihm NULL zugewiesen Sich angewöhnen, jeden Zeiger bei der Deklaration mit NULL zu initialisieren. int *pi = NULL; *pi = 25; Das Programm stürzt kontrolliert ab 26 von 50

26 Array vs Pointerschreibweise Beispiel: Kopieren einer Zeichenkette In Zeiger-Notation: char i; for (i=0; i<10; i++) { b[i] = a[i]; } char *pa = &a[0]; char *pb = &b[0]; int i; for (i = 0;i< 10;i++) { *pb = *pa; pa++; pb++; } for (;*pb++=*pa++;); Die rechten Versionen sind schlechter lesbar! 27 von 50

27 Zeigerarithmetik und Arrays double da[4]; double *pda1; double *pda2; int diff; pda1 = &da[1]; pda2 = &da[2]; diff = pda2 - pda1; Wenn zwei Zeiger auf ein Array voneinander subtrahiert werden, erhält man die Anzahl der Elemente dazwischen da[0] da[1] da[2] da[3] pda1 pda C C C von 50

28 Zeigerarithmetik und Arrays Zeiger und Arrays sind in C eng verbunden Der Arrayname kann als konstanter Zeiger auf das erste Array-Element aufgefasst werden int a[10]; pa = a; /* wie: pa = &a[0]; */ *(a + 3) = 42 ; /* gleich wie a[3]=42; vorsicht */ a++ ; /* nicht erlaubt!! */ 29 von 50

29 Fallstricke Mehrere Zeiger Variablen definieren int *pi, pa; /* nur pi ist ein Zeiger, pa NICHT */ int * pi, pa; /* dito */ int* pi, pa; /* dito */ 30 von 50

30 Fazit Zeiger In einer normalen Variablen steht immer der Wert, den man in dieser Variablen speichern will Ein Zeiger, int * pa, ist auch eine Variable Die Grösse eines Zeigers ist architekturabhängig (häufig 4 oder 8 Bytes) Dort steht aber nicht irgendein Zahlenwert, sondern die Speicheradresse einer anderen Variablen 31 von 50

31 Datenstrukturen mit struct 32 von 50

32 Structs Mehrere Variablen zu einer Einheit zusammenfassen Im Unterschied zu Arrays kann eine Struktur aus Elementen verschiedener Datentypen zusammengesetzt sein struct Complex { double real; double imag; }; struct Complex x; Semikolon nicht vergessen! Auf die Werte des Structs greift man mit der "." Notation zu x.real = 7.0; x.imag = 6.4; 33 von 50

33 Structs weitere Beispiele Definition des Structs und Variablendeklaration kombiniert struct Complex { double real; double imag; } x; /* inklusive Variablendefinition */ 34 von 50

34 Structs weitere Beispiele Es können auch mehrere Variablen vom Struct Typ definiert werden struct Datum { int tag; int monat; int jahr; }; struct Datum meingeburtstag = {17, 4, 1976}; struct Datum geburtstag; 35 von 50

35 Zuweisung Strukturvariablen können einander zugewiesen werden Dabei werden die Werte kopiert: Unterschied zu Arrays! struct Datum meingeburtstag = {17, 4, 1976}; struct Datum geburtstag; geburtstag = meingeburtstag ; geburtstag.tag = 25; printf("%d", meingeburtstag.tag); // 17 printf("%d", geburtstag.tag); // von 50

36 Struct Definition mit typedef Ein Strukt kann auch mit typedef angelegt (definiert) werden typedef struct { int tag; int monat; int jahr; } Datum; Datum variable; Abwägen: Es ist elegant, einfach NeuerTyp variable; schreiben zu können. Auf der anderen Seite wird mit struct NeuerTyp variable; klarer, dass es sich um eine Datenstruktur handelt... Hier kein "strukt" mehr nötig! 37 von 50

37 Zeiger auf Datenstrukturen 38 von 50

38 Zeiger auf Strukturen typedef struct { int tag; int monat; int jahr; } Datum; Datum geburtstag; Datum *pgb = &geburtstag; /* Zeiger auf geburtstag */ printf("%d", (*pgb).tag); /* tag ausgeben */ (*pgb).tag = 17; /* tag setzen */ 39 von 50

39 Zeiger auf Strukturen: Operator -> Kürzere Schreibweise mit dem -> Operator: printf("%d", pgb-> tag); /* tag auswaehlen */ pmw -> tag = 17; /* Feld setzen */ Der -> Operator dereferenziert und wählt ein Feld aus (*pmw).tag pmw -> tag Ersetzt also '*' und '.' und behebt das Problem der sonst notwendigen Klammerung; meistens wird diese Schreibweise bevorzugt 40 von 50

40 Verkettete Strukturen Es gibt auch die Möglichkeit, dass ein Element einer Struktur ein Zeiger ist auf diese Struktur So kann man Strukturen miteinander verketten Dies wird im Zusammenhang zum Aufbau dynamischer Datenstrukturen, (z.b. verketteter Listen) verwendet 41 von 50

41 Verkettete (rekursive) Strukturen: Beispiel mw1 mw2 pnext typedef struct Datum { int tag; int monat; int jahr; struct Datum *pnext; } Datum; Datum mw1, mw2; mw1.pnext = &mw2; /* Strukturen verketten */ 42 von 50

42 Spezielle Zeiger und komplexe Deklarationen 43 von 50

43 Komplexe Deklarationen char * args[]; args ein Array mit Elementen vom Typ Zeiger auf char oder oder auch auch char** char** int main (int argc, char* args[]) strings strings Grösse Grösse des des Arrays Arrays Also: Zeiger auf char array 44 von 50

44 void-pointer Der void-zeiger void* ist zu jedem Datentyp kompatibel Daher auch untypisierter oder generischer Zeiger genannt Ein void-zeiger lässt sich in jeden anderen Zeiger und zurück wandeln Problematisch mit void-pointer: Zeigerarithmetik, da dem Compiler der Speicherplatzverbrauch pro Variable nicht bekannt ist 45 von 50

45 void-pointer Beispiel int *pint; void *pvoid; pvoid=pint; /* beide zeigen jetzt auf das gleiche Element */ pint+=1; /* zeigt nun auf das naechste Element */ pvoid+=sizeof(int); /* zeigt jetzt auch auf das naechste int Element */ 46 von 50

46 Weitere komplexe Deklarationen double * b [10]; b ist ein Array mit 10 Elementen vom Typ Zeiger auf double Also: 10 Zeiger auf double 47 von 50

47 Weitere komplexe Deklarationen double (* c) [10]; c ist ein Zeiger auf ein Array mit 10 Elementen vom Typ double Also: Zeiger auf 10 double's 48 von 50

48 Weitere komplexe Deklarationen double * (* d) [10]; d ist ein Zeiger auf ein Array mit 10 Elementen vom Typ Zeiger auf double Also: Zeiger auf 10 Zeiger auf double 49 von 50

49 Noch Fragen not not amused amused 50 von 50