Felder: Motivation. Felder (Arrays) und Zeiger (Pointers) - Teil I. Felder: erste Anwendung. Felder: erste Anwendung. Felder: erste Anwendung

Transkript

1 1/16/12 Felder (Arrays) und Zeiger (Pinters) - Teil I Feldtyen, Sieb des Eratsthenes, Iteratin, Zeigertyen, Zeigerarithmetik, dynamische Seicherverwaltung Felder: Mtivatin n Wir können jetzt über Zahlen iterieren: fr (int i=; i<n; ++i)... n Oft muss man aber über Daten iterieren (Beisiel: finde ein Kin in Zürich, das heute The C++ Legacy zeigt) n Felder dienen zum Seichern vn Flgen gleichartiger Daten (Beisiel: Sielläne aller Zürcher Kins) Felder: erste Anwung Das Sieb des Eratsthenes berechnet alle Primzahlen < n Methde: Ausstreichen der Nicht- Primzahlen Felder: erste Anwung Das Sieb des Eratsthenes berechnet alle Primzahlen < n Methde: Ausstreichen der Nicht- Primzahlen Streiche alle echten Vielfachen vn und gehe zur nächsten Zahl Felder: erste Anwung Das Sieb des Eratsthenes berechnet alle Primzahlen < n Methde: Ausstreichen der Nicht- Primzahlen Felder: erste Anwung Das Sieb des Eratsthenes berechnet alle Primzahlen < n Methde: Ausstreichen der Nicht- Primzahlen Streiche alle echten Vielfachen vn und gehe zur nächsten Zahl 1

2 1/16/12 Felder: erste Anwung Das Sieb des Eratsthenes berechnet alle Primzahlen < n Methde: Ausstreichen der Nicht- Primzahlen Felder: erste Anwung Das Sieb des Eratsthenes berechnet alle Primzahlen < n Methde: Ausstreichen der Nicht- Primzahlen Frage: wie streichen wir Zahlen aus??? Am Ende des Streichungsrzesses bleiben genau die Primzahlen übrig! mit einem Feld! Felder: Imlementierung Sieb des Eratsthenes Felder: Imlementierung Sieb des Eratsthenes cnst unsigned int n = 1; // definitin and initializatin: rvides us with // Bleans [],..., [] bl [n]; fr (unsigned int i = ; i < n; ++i) [i] = ; // cmutatin and utut std::cut << "Prime numbers in 2,..., " << << ":\n"; fr (unsigned int i = 2; i < n; ++i) if (![i]) // i is rime std::cut << i << " "; // crss ut all rer multiles f i fr (unsigned int m = 2*i; m < n; m += i) [m] = true; std::cut << "\n"; Berechnet alle Primzahlen < 1 n ist eine Knstante, sllte als auch s deklariert werden! cnst unsigned int n = 1; // definitin and initializatin: rvides us with // Bleans [],..., [] bl [n]; fr (unsigned int i = ; i < n; ++i) [i] = ; // cmutatin and utut std::cut << "Prime numbers in 2,..., " << << ":\n"; fr (unsigned int i = 2; i < n; ++i) if (![i]) // i is rime std::cut << i << " "; // crss ut all rer multiles f i fr (unsigned int m = 2*i; m < n; m += i) [m] = true; std::cut << "\n"; Feld: [i] gibt an, b i schn ausgestrichen wurde return ; return ; Felder: Imlementierung Sieb des Eratsthenes Felder: Definitin cnst unsigned int n = 1; Deklaratin einer Feldvariablen (array): // definitin and initializatin: rvides us with // Bleans [],..., [] bl [n]; fr (unsigned int i = ; i < n; ++i) [i] = ; T a [exr ] Wert k ist bei Kmilierung bekannt (z.b. Literal, Knstante) // cmutatin and utut std::cut << "Prime numbers in 2,..., " << << ":\n"; fr (unsigned int i = 2; i < n; ++i) if (![i]) // i is rime std::cut << i << " "; // crss ut all rer multiles f i fr (unsigned int m = 2*i; m < n; m += i) [m] = true; std::cut << "\n"; return ; Das Sieb: gehe zur jeweils nächsten nichtgestrichenen Zahl i (diese ist Primzahl), gib sie aus und streiche alle echten Vielfachen vn i aus zugrundelieger Ty Variable des Feld-Tys knstanter ganzzahliger Ausdruck; Wert gibt Länge des Feldes an Ty vn a : T [k ] Wertebereich vn T [k ]: T k 2

3 1/16/12 Felder: Definitin Deklaratin einer Feldvariablen (array): T a [exr ] zugrundelieger Ty Variable des Feld-Tys knstanter ganzzahliger Ausdruck; Wert gibt Länge des Feldes an Beisiel: Wert k ist bei Kmilierung bekannt (z.b. Literal, Knstante) bl [n] Felder variabler Länge? Praktischer (aber nicht erlaubt) wäre: // inut f n std::cut << Cmute rime numbers in [2, n) fr n =? ; unsigned int n; std::cin >> n; // definitin and initializatin: rvides us with // Bleans [],..., [] bl [n]; // Fehler!... kein knstanter Ausdruck! Felder variabler Länge? Praktischer (und erlaubt) wäre: // inut f n std::cut << Cmute rime numbers in [2, n) fr n =? ; unsigned int n; std::cin >> n; // definitin and initializatin: rvides us with // Bleans [],..., [] bl* cnst = new bl[n]; // k!... s geht es (Erklärung flgt)! Feld-Initialisierung n int a[5]; n int a[5] = 4, 3, 5, 2, 1; auch k; Länge wird deduziert Die 5 Elemente vn a bleiben uninitialisiert (können säter Werte zugewiesen bekmmen) Die 5 Elemente vn a werden mit einer Initialisierungsliste initialisiert n int a[] = 4, 3, 5, 2, 1; Seicherlayut eines Feldes Ein Feld belegt einen zusammenhängen Seicherbereich Beisiel: Feld mit 4 Elementen Wahlfreier Zugriff (Randm Access) Der L-Wert a [ exr ] Wert i hat Ty T und bezieht sich auf das i te Element des Feldes a (Zählung ab ) Seicherzellen für jeweils einen Wert vm Ty T a[] a[1] a[2] a[3] 3

4 1/16/12 Wahlfreier Zugriff (Randm Access) a [ exr ] Wahlfreier Zugriff (Randm Access) Wahlfreier Zugriff ist sehr effizient (Reduktin auf Adressarithmetik): : Adresse vn a + si : Adresse vn a[i] Der Wert i vn exr heisst Feldindex []: Subskrit-Oeratr s : Seicherbedarf vn T (in Zellen) a[i] Felder sind rimitiv Man kann Felder nicht wie bei anderen Tyen initialisieren und zuweisen: Warum? int a[5] = 4,3,5,2,1; int b[5]; b = a; // Fehler! int c[5] = a; // Fehler! Felder sind rimitiv Felder sind Erblast der Srache C und aus heutiger Sicht rimitiv In C, Felder sind sehr maschinennah und effizient, bieten aber keinen Luxus wie eingebautes Initialisieren und Kieren Die Standard-Biblithek bietet kmfrtable Alternativen (mehr dazu säter) Felder als Daten-Cntainer Cntainer: Objekt, das andere Objekte seichern kann......und die Möglichkeit anbietet, über die geseicherten Objekte zu iterieren (Kinrgramme...) Iteratin in Feldern geht über wahlfreien Zugriff: a[], a[1],...,a[] Iteratin durch wahlfreien Zugriff fr (unsigned int i = ; i < 1; ++i) [i] = ; Berechnungsaufwand: 4

5 1/16/12 Iteratin durch wahlfreien Zugriff fr (unsigned int i = ; i < 1; ++i) [i] = ; Berechnungsaufwand (Adressberechnung): +s Iteratin durch wahlfreien Zugriff fr (unsigned int i = ; i < 1; ++i) [i] = ; Berechnungsaufwand (Adressberechnung): +2s Iteratin durch wahlfreien Zugriff fr (unsigned int i = ; i < 1; ++i) [i] = ; Berechnungsaufwand (Adressberechnung): +3s Iteratin durch wahlfreien Zugriff fr (unsigned int i = ; i < 1; ++i) [i] = ; Berechnungsaufwand (Adressberechnung): +s Iteratin durch wahlfreien Zugriff Effizientere und natürlichere Iteratin fr (unsigned int i = ; i < 1; ++i) [i] = ; Berechnungsaufwand (Adressberechnung): Pr Feldelement eine Additin und eine Multilikatin + i s +s +2s Addieren vn s: gehe zum nächsten Element +s 5

6 1/16/12 Effizientere und natürlichere Iteratin Berechnungsaufwand (Adressberechnung): Pr Feldelement eine Additin vrher + s Effizientere und natürlichere bl* cnst = ; bl* cnst = + n; Pr Feldelement eine Additin // tr t first element // tr after last element vrher + s Effizientere und natürlichere Buchlesen: Wahlfreier Zugriff vs. natürliche Iteratin bl* cnst = ; // tr t first element bl* cnst = + 1;// tr after last element wird nch genau erklärt! Pr Feldelement eine Additin vrher + s Wahlfreier Zugriff: öffne Buch auf S.1 klae Buch zu öffne Buch auf S.2-3 klae Buch zu öffne Buch auf S Natürliche Iteratin: öffne Buch auf S.1 blättere um blättere um blättere um blättere um... Zeiger Zeiger-Tyen erlauben das Reräsentieren vn und das Rechnen mit Adressen unterstützen insbesndere die Oeratin gehe zum nächsten Element eines Feldes sind mit Vrsicht zu verwen (beim Verrechnen mit Adressen stürzt meist das Prgramm ab) T * zugrundelieger Ty srich: Zeiger auf T T * hat als mögliche Werte Adressen vn Objekten des Tys T Ausdrücke vm Ty T * heissen Zeiger 6

7 1/16/12 Zeiger: Visualisierung Adresseratr Zeiger auf das Objekt (Wert vn ist die Adresse des Objekts) liefert einen Zeiger (R-Wert) auf ein beliebiges Objekt, gegeben durch einen L-Wert & L-Wert Objekt im Seicher int i = 5; int* itr = &i; itr i & Dereferenzierungseratr liefert einen L-Wert für ein Objekt, gegeben durch einen Zeiger auf das Objekt * R-Wert Dereferenzierungseratr = Adresseratr -1 Zeiger (R-Wert) & * int i = 5; itr int* itr = &i; int j = *itr; // j = 5 i * Objekt (L-Wert) Felder sind Zeiger Felder sind Zeiger Jedes Feld vm Ty T [k] ist in den Ty T* knvertierbar Feld-nach-Zeiger-Knversin Ergebnis der Knversin ist ein Zeiger auf das erste Element (Feldindex ) Beisiel: int a[5]; int* = a; a Tritt ein Feld in einem Ausdruck auf, s wird es autmatisch knvertiert Im Rechner assiert dabei nichts: ein Feld ist hnehin nur durch die Adresse des ersten Elements reräsentiert. 7

8 1/16/12 Zeiger +, - ganze Zahl Zeiger ==,!=, <, >, <=, >= Zeiger Zeiger +, - ganze Zahl Zeiger ==,!=, <, >, <=, >= Zeiger : Zeiger auf ein Feldelement...der auf Zelle direkt hinter dem Feld (ast-the- Zeiger) a[] a[1] a[2] a[3] a[4] a[5] a[] a[1] a[2] a[3] a[4] a[5] Zeiger +, - ganze Zahl Zeiger ==,!=, <, >, <=, >= Zeiger Zeiger +, - ganze Zahl Zeiger ==,!=, <, >, <=, >= Zeiger Adden mit Ergebniszeiger ausserhalb dieses Bereichs sind illegal! a[] a[1] a[2] a[3] a[4] a[5] a[] a[1] a[2] a[3] a[4] a[5] Zeiger +, - ganze Zahl Zeiger ==,!=, <, >, <=, >= Zeiger +=, -=, ++, -- gibt es auch, mit der üblichen Bedeutung Zeiger +, - ganze Zahl Zeiger ==,!=, <, >, <=, >= Zeiger!= : nicht == <= : < der == q < == < r > : nicht <= >= : nicht < a[] a[1] a[2] a[3] a[4] a[5] a[] a[1] a[2] a[3] a[4] a[5] 8

9 1/16/12 Zeiger +, - ganze Zahl Zeiger ==,!=, <, >, <=, >= Zeiger -2 Zeiger +, - ganze Zahl Zeiger ==,!=, <, >, <=, >= Zeiger -2 q r s q r s a[] a[1] a[2] a[3] a[4] a[5] a[] a[1] a[2] a[3] a[4] a[5] Zeiger +, - ganze Zahl Zeiger ==,!=, <, >, <=, >= Zeiger -1 q r r = 2 q = 1 r q = 3 Die Wahrheit über den Subskrit-Oeratr arbeitet eigentlich auf Zeigern: a [ exr ] ist eine Abkürzung für * (a + exr ) Besiel: exr hat Wert 2 a[] a[1] a[2] a[3] a[4] a[5] a[] a[1] a[2] a[3] a[4] a[5] bl* cnst = ; //tr t first element bl* cnst = + 1; //tr after last element wird nch genau erklärt! bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element Feld-nach-Zeiger-Knversin 9

10 1/16/12 ist eine Knstante! bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element cnst bl* wäre ein variabler Zeiger auf cnst bl! bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element Feld-nach-Zeiger-Knversin Feld-nach-Zeiger-Knversin bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element Feld-nach-Zeiger-Knversin Zeiger + ganze Zahl bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element Zeiger-Initialisierung bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element Zeiger-Vergleich Dereferenzierung, Zuweisung 1

11 1/16/12 bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element Zeigerinkrement Zeiger-Vergleich bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element Dereferenzierung, Zuweisung Zeigerinkrement, usw... bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element...usw., Zeigerinkrement Zeiger-Vergleich 11

12 1/16/12 bl* cnst = ; // tr t first element bl* cnst = + n; // tr after last element fertig! Warum Zeiger? Die (geringfügig) schnellere Iteratin ist nicht der Punkt (Lesbarkeit sricht ft eher für wahlfreien Zugriff) Grund 1: wir brauchen sie für Felder mit variabler Länge (gleich...) Grund 2: std:: Cntainer-Algrithmen (Srtieren,...) brauchen Iteratren Zeiger sind die Iteratren der Felder! Dynamischer Seicher wie besrgen wir Seicher, der bei Kmilierung nicht vrhersehbar ist? Sieb des Eratsthenes mit Eingabe vn n Allgemein: Feld variabler Länge New-Ausdrücke new T new-oeratr Ausdruck vm Ty T * (Zeiger) Effekt: neuer Seicher für ein Objekt vm Ty T wird bereitgestellt; der Wert des Ausdrucks ist dessen Adresse New-Ausdrücke new T [exr ] new-oeratr Ausdruck vm Ty T * (Zeiger) Ty int, Wert n ; exr nicht ntwigerweise knstant Effekt: neuer Seicher für ein Feld der Länge n mit zugrundeliegem Ty T wird bereitgestellt; Wert des Ausdrucks ist Adresse des ersten Elements Der Hea Hautseicherbereich, aus dem das Prgramm neuen Seicher hlen kann. int* i = new int; int* a = new int[3]; hea ( dynamischer Seicher ) 12

13 1/16/12 Sieb des Eratsthenes neu: dynamischer Seicher Sieb des Eratsthenes neu: dynamischer Seicher // inut // inut std::cut << "Cmute rime numbers std::cut << "Cmute rime numbers in 2,..., fr n =? "; in 2,..., fr n =? "; cnst unsigned int n = 1; unsigned int n; cnst unsigned int n = 1; unsigned int n; std::cin >> n; std::cin >> n; bl [n]; bl* = new bl[n]; bl [n]; bl* = new bl[n]; fr (unsigned int i = ; i < n; ++i) fr (unsigned int i = ; i < n; ++i) fr (unsigned int i = ; i < n; ++i) fr (unsigned int i = ; i < n; ++i) [i] = ; [i] = ; [i] = ; [i] = ; // cmutatin and utut // cmutatin and utut // cmutatin and utut // cmutatin and utut delete[] ; delete[] ; return ; Subskrit-Oeratr auf Zeiger return ; return ; Freigabe des nicht mehr benötigten dynamischen Seichers return ; Delete-Ausdrücke Mit new erzeugte Objekte haben dynamische Seicherdauer: sie leben, bis sie exlizit gelöscht werden: delete exr int* i = new int;... delete i; Delete-Ausdrücke Mit new erzeugte Objekte haben dynamische Seicherdauer: sie leben, bis sie exlizit gelöscht werden. delete[] exr int* a = new int[3];... delete[] a; delete-oeratr Zeiger vm Ty T *, der auf ein vrher mit new bereitgestelltes Objekt zeigt; Effekt: Seicher auf dem Hea wird wieder freigegeben. delete-oeratr Zeiger vm Ty T *, der auf ein vrher mit new bereitgestelltes Feld zeigt; Effekt: Seicher auf dem Hea wird wieder freigegeben. Dynamische-Seicher- Richtlinie Zu jedem new gibt es ein asses delete int* a = new int[3];... delete[] a; Dynamische-Seicher- Richtlinie Zu jedem new gibt es ein asses delete Nichtbeflgung führt zu Seicherlecks (ungenutzter, aber nicht mehr verfügbarer Seicher auf dem Hea) 13