Datenkapselung: public / private

Transkript

1 Klassen Klassen, Memberfunktionen, Konstruktoren, Stapel, verkettete Liste, dynamischer Speicher, Copy-Konstruktor, Zuweisungsoperator, Destruktor, Konzept Dynamischer Datentyp

2 Datenkapselung: public / private 628 class rational { int n; int d; // INV: d!= 0 ; Anwendungscode: rational r; r.n = 1; // error: n is private r.d = 2; // error: d is private int i = r.n; // error: n is private

3 Datenkapselung: public / private 628 class rational { int n; int d; // INV: d!= 0 ; Anwendungscode: rational r; r.n = 1; // error: n is private r.d = 2; // error: d is private int i = r.n; // error: n is private Gute Nachricht: r.d = 0 aus Versehen geht nicht mehr

4 Datenkapselung: public / private 628 class rational { int n; int d; // INV: d!= 0 ; Anwendungscode: rational r; r.n = 1; // error: n is private r.d = 2; // error: d is private int i = r.n; // error: n is private Gute Nachricht: r.d = 0 aus Versehen geht nicht mehr Schlechte Nachricht: Der Kunde kann nun gar nichts mehr machen...

5 Datenkapselung: public / private 628 class rational { int n; int d; // INV: d!= 0 ; Anwendungscode: rational r; r.n = 1; // error: n is private r.d = 2; // error: d is private int i = r.n; // error: n is private Gute Nachricht: r.d = 0 aus Versehen geht nicht mehr Schlechte Nachricht: Der Kunde kann nun gar nichts mehr machen und wir auch nicht (kein operator+,... )

6 629 Memberfunktionen: Deklaration class rational { public: // POST: return value is the numerator of this int numerator () const { return n; // POST: return value is the denominator of this int denominator () const { return d; private: int n; int d; // INV: d!= 0 ;

7 629 öffentlicher Bereich Memberfunktionen: Deklaration class rational { public: // POST: return value is the numerator of this int numerator () const { return n; // POST: return value is the denominator of this int denominator () const { return d; private: int n; int d; // INV: d!= 0 ;

8 629 öffentlicher Bereich Memberfunktionen: Deklaration class rational { public: // POST: return value is the numerator of this int numerator () const { return n; Memberfunktion // POST: return value is the denominator of this int denominator () const { return d; private: int n; int d; // INV: d!= 0 ;

9 629 öffentlicher Bereich Memberfunktionen: Deklaration class rational { public: // POST: return value is the numerator of this int numerator () const { Memberfunktion return n; // POST: return value is the denominator of this int denominator () const { Memberfunktionen haben return d; Zugriff auf private Daten private: int n; int d; // INV: d!= 0 ;

10 Memberfunktionen: Aufruf 630 // Definition des Typs class rational {... ;... // Variable des Typs rational r; Member-Zugriff int n = r.numerator(); // Zaehler int d = r.denominator(); // Nenner

11 Memberfunktionen: Definition 631 // POST: returns numerator of *this int numerator () const { return n;

12 Memberfunktionen: Definition??? 631 // POST: returns numerator of *this int numerator () const { return n;

13 Memberfunktionen: Definition 631 // POST: returns numerator of *this int numerator () const { return n; r.numerator() Eine Memberfunktion wird für einen Ausdruck der Klasse aufgerufen.

14 Memberfunktionen: Definition 631 // POST: returns numerator of *this int numerator () const { return n; r.numerator() Eine Memberfunktion wird für einen Ausdruck der Klasse aufgerufen. In der Funktion: *this ist der Name dieses impliziten Arguments.

15 Memberfunktionen: Definition 631 // POST: returns numerator of *this int numerator () const { return n; r.numerator() Eine Memberfunktion wird für einen Ausdruck der Klasse aufgerufen. In der Funktion: *this ist der Name dieses impliziten Arguments. Das const bezieht sich auf *this

16 Memberfunktionen: Definition 631 // POST: returns numerator of *this int numerator () const { return n; r.numerator() Eine Memberfunktion wird für einen Ausdruck der Klasse aufgerufen. In der Funktion: *this ist der Name dieses impliziten Arguments. Das const bezieht sich auf *this n ist Abkürzung für (*this).n

17 This rational vs. dieser Bruch 632 class rational { int n;... ; int numerator () const { return.n; rational r;... std::cout << r.numerator();

18 This rational vs. dieser Bruch 632 class rational { int n;... ; int numerator () const { return (*this).n; rational r;... std::cout << r.numerator();

19 632 This rational vs. dieser Bruch So würde es aussehen... class rational { int n;... ; int numerator () const { return (*this).n; rational r;... std::cout << r.numerator();

20 632 This rational vs. dieser Bruch So würde es aussehen... class rational { int n;... ; int numerator () const { return (*this).n;... ohne Memberfunktionen struct bruch { int n;... ; int numerator (const bruch dieser) { return ( dieser).n; rational r;... std::cout << r.numerator(); bruch r;.. std::cout << numerator(&r);

21 Member-Definition: In-Class 633 class rational { int n;... ; int numerator () const { return n;... Keine Trennung zwischen Deklaration und Definition (schlecht für Bibliotheken)

22 Member-Definition: In-Class vs. Out-of-Class 633 class rational { int n;... class rational { int n;... ; int numerator () const { return n;... Keine Trennung zwischen Deklaration und Definition (schlecht für Bibliotheken) ; int numerator () const;... int rational::numerator () const { return n; So geht s auch.

23 Initialisierung? Konstruktoren! 635 class rational { public: rational ( int num, int den) : n (num), d (den) { assert (den!= 0);... ;... rational r (2,3); // r = 2/3

24 Initialisierung? Konstruktoren! 635 class rational { public: rational ( int num, int den) : n (num), d (den) { assert (den!= 0);... ;... rational r (2,3); // r = 2/3 Initialisierung der Membervariablen Funktionsrumpf.

25 Initialisierung rational = int? 637 class rational { public: rational ( int num) : n (num), d (1) {... ;... rational r (2); // Explizite Initialisierung mit 2 rational s = 2; // Implizite Konversion

26 Initialisierung rational = int? 637 class rational { public: rational ( int num) : n (num), d (1) { Leerer Funktionsrumpf... ;... rational r (2); // Explizite Initialisierung mit 2 rational s = 2; // Implizite Konversion

27 Der Default-Konstruktor 639 class rational { public: Leere Argumentliste... rational () : n (0), d (1) {... ;... rational r; // r = 0

28 Der Default-Konstruktor 639 class rational { public: Leere Argumentliste... rational () : n (0), d (1) {... ;... rational r; // r = 0 Es gibt keine uninitialisierten Variablen vom Typ rational mehr!

29 RAT PACK R Reloaded Kundenprogramm sieht nun so aus: // POST: double approximation of r double to_double (const rational r) { double result = r.numerator(); return result / r.denominator();

30 RAT PACK R Reloaded Kundenprogramm sieht nun so aus: // POST: double approximation of r double to_double (const rational r) { double result = r.numerator(); return result / r.denominator(); Wir können die Memberfunktionen zusammen mit der Repräsentation anpassen.

31 RAT PACK R Reloaded vorher class rational {... private: int n; int d; ;

32 RAT PACK R Reloaded vorher class rational {... private: int n; int d; ; int numerator () const { return n;

33 RAT PACK R Reloaded vorher class rational {... private: int n; int d; ; int numerator () const { return n; nachher class rational {... private: unsigned int n; unsigned int d; bool is_positive; ;

34 RAT PACK R Reloaded... vorher class rational {... private: int n; int d; ; int numerator () const { return n; nachher class rational {... private: unsigned int n; unsigned int d; bool is_positive; ; int numerator () const{ if (is_positive) return n; else { int result = n; return result; 642

35 RAT PACK R Reloaded? 643 class rational {... private: unsigned int n; unsigned int d; bool is_positive; ; int numerator () const { if (is_positive) return n; else { int result = n; return result;

36 RAT PACK R Reloaded? 643 class rational {... private: unsigned int n; unsigned int d; bool is_positive; ; int numerator () const { if (is_positive) return n; else { int result = n; return result; Wertebereich von Zähler und Nenner wieder wie vorher

37 643 RAT PACK R Reloaded? class rational {... private: unsigned int n; unsigned int d; bool is_positive; ; int numerator () const { if (is_positive) return n; else { int result = n; return result; Wertebereich von Zähler und Nenner wieder wie vorher Dazu noch möglicher Überlauf

38 Datenkapselung noch unvollständig 644 Die Sicht des Kunden (rational.h): class rational { public: // POST: returns numerator of this int numerator () const;... private: // none of my business ;

39 Datenkapselung noch unvollständig 644 Die Sicht des Kunden (rational.h): class rational { public: // POST: returns numerator of this int numerator () const;... private: // none of my business ; Wir legen uns auf Zähler-/Nennertyp int fest.

40 Datenkapselung noch unvollständig Die Sicht des Kunden (rational.h): class rational { public: // POST: returns numerator of this int numerator () const;... private: // none of my business ; Wir legen uns auf Zähler-/Nennertyp int fest. Lösung: Nicht nur Daten, auch Typen kapseln (Handout). 644

41 Motivation: Stapel 648

42 Motivation: Stapel

43 Motivation: Stapel push(4)

44 Motivation: Stapel push(4) pop()

45 Motivation: Stapel push(4) pop() pop() 5 1 2

46 Motivation: Stapel push(4) pop() pop() push(1)

47 Motivation: Stapel push(4) pop() pop() push(1) top() 3

48 Motivation: Stapel ( push, pop, top, empty ) push(4) pop() pop() push(1) top() empty() false

49 Motivation: Stapel ( push, pop, top, empty ) push(4) pop() pop() push(1) top() empty() false Ziel: Bau einer Stapel-Klasse!

50 Motivation: Stapel ( push, pop, top, empty ) push(4) pop() pop() push(1) top() empty() false Ziel: Bau einer Stapel-Klasse! Frage: wie schaffen wir bei push neuen Platz auf dem Stapel?

51 Wir brauchen einen neuen Container! 650 Unser Haupt-Container bisher: Array (T[])

52 Wir brauchen einen neuen Container! 650 Unser Haupt-Container bisher: Array (T[]) Zusammenhängender Speicherbereich, wahlfreier Zugriff (auf i-tes Element)

53 Wir brauchen einen neuen Container! 650 Unser Haupt-Container bisher: Array (T[]) Zusammenhängender Speicherbereich, wahlfreier Zugriff (auf i-tes Element) Simulation eines Stapels durch ein Array? top

54 Wir brauchen einen neuen Container! 650 Unser Haupt-Container bisher: Array (T[]) Zusammenhängender Speicherbereich, wahlfreier Zugriff (auf i-tes Element) Simulation eines Stapels durch ein Array? Nein, irgendwann ist das Array voll. top Hier kein push(3) möglich!

55 Arrays können wirklich nicht alles Einfügen oder Löschen von Elementen in der Mitte ist aufwändig Wollen wir hier einfügen, müssen wir alles rechts davon verschieben (falls da überhaupt noch Platz ist!)

58 Arrays können wirklich nicht alles Einfügen oder Löschen von Elementen in der Mitte ist aufwändig Wollen wir hier löschen, müssen wir alles rechts davon verschieben

61 653 Der neue Container: Verkettete Liste Kein zusammenhängender Speicherbereich und kein wahlfreier Zugriff

62 653 Der neue Container: Verkettete Liste Kein zusammenhängender Speicherbereich und kein wahlfreier Zugriff Jedes Element kennt seinen Nachfolger

63 653 Der neue Container: Verkettete Liste Kein zusammenhängender Speicherbereich und kein wahlfreier Zugriff Jedes Element kennt seinen Nachfolger Zeiger

64 653 Der neue Container: Verkettete Liste Kein zusammenhängender Speicherbereich und kein wahlfreier Zugriff Jedes Element kennt seinen Nachfolger Einfügen und Löschen beliebiger Elemente ist einfach, auch am Anfang der Liste Zeiger

65 653 Der neue Container: Verkettete Liste Kein zusammenhängender Speicherbereich und kein wahlfreier Zugriff Jedes Element kennt seinen Nachfolger Einfügen und Löschen beliebiger Elemente ist einfach, auch am Anfang der Liste Ein Stapel kann als verkettete Liste realisiert werden Zeiger

66 Verkettete Liste: Zoom

67 Verkettete Liste: Zoom 654 Element (Typ struct list_node) 1 5 6

68 Verkettete Liste: Zoom 654 Element (Typ struct list_node) key (Typ int)

69 Verkettete Liste: Zoom 654 Element (Typ struct list_node) key (Typ int) next (Typ list_node*)

70 Verkettete Liste: Zoom 654 Element (Typ struct list_node) key (Typ int) next (Typ list_node*) struct list_node { int key; list_node next; // constructor list_node (int k, list_node n) : key (k), next (n) { ;

71 Stapel = Zeiger aufs oberste Element 655 Element (Typ struct list_node) key (Typ int) next (Typ list_node*) class stack { public: void push (int value) { private: list_node top_node; ;

72 Sneak Preview: push(4) 656 void push (int value) { top_node = new list_node (value, top_node); top_node 1 5 6

73 Sneak Preview: push(4) 656 void push (int value) { top_node = new list_node (value, top_node); top_node 1 5 6

74 Sneak Preview: push(4) 656 void push (int value) { top_node = new list_node (value, top_node); top_node

75 Sneak Preview: push(4) 656 void push (int value) { top_node = new list_node (value, top_node); top_node

76 Der new-ausdruck 658 zugrundeliegender Typ new T (...) Typ T* new-operator Konstruktor-Argumente

77 Der new-ausdruck 658 zugrundeliegender Typ new T (...) Typ T* new-operator Konstruktor-Argumente Effekt: Neues Objekt vom Typ T wird im Speicher angelegt...

78 658 Der new-ausdruck zugrundeliegender Typ new T (...) Typ T* new-operator Konstruktor-Argumente Effekt: Neues Objekt vom Typ T wird im Speicher angelegt und mit Hilfe des passenden Konstruktors initialisiert.

79 658 Der new-ausdruck zugrundeliegender Typ new T (...) Typ T* new-operator Konstruktor-Argumente Effekt: Neues Objekt vom Typ T wird im Speicher angelegt und mit Hilfe des passenden Konstruktors initialisiert. Wert: Adresse des neuen Objekts

80 Der new-ausdruck: push(4) 660 top_node = new list_node (value, top_node); top_node 1 5 6

81 Der new-ausdruck: push(4) 660 Effekt: Neues Objekt vom Typ T wird im Speicher angelegt... top_node = new list_node (value, top_node); top_node 1 5 6

82 Der new-ausdruck: push(4) 660 Effekt: Neues Objekt vom Typ T wird im Speicher angelegt und mit Hilfe des passenden Konstruktors initialisiert. top_node = new list_node (value, top_node); top_node

83 Der new-ausdruck: push(4) 660 Effekt: Neues Objekt vom Typ T wird im Speicher angelegt und mit Hilfe des passenden Konstruktors initialisiert. Wert: Adresse des neuen Objekts top_node = new list_node (value, top_node); top_node

84 Der delete-ausdruck 661 Objekte, die mit new erzeugt worden sind, haben dynamische Speicherdauer: sie leben, bis sie explizit gelöscht werden.

85 Der delete-ausdruck 661 Objekte, die mit new erzeugt worden sind, haben dynamische Speicherdauer: sie leben, bis sie explizit gelöscht werden. delete expr Typ void delete-operator Zeiger vom Typ T*, der auf ein vorher mit new erzeugtes Objekt zeigt

86 Der delete-ausdruck 661 Objekte, die mit new erzeugt worden sind, haben dynamische Speicherdauer: sie leben, bis sie explizit gelöscht werden. delete expr Typ void delete-operator Zeiger vom Typ T*, der auf ein vorher mit new erzeugtes Objekt zeigt Effekt: Objekt wird gelöscht, Speicher wird wieder freigegeben

87 Wer geboren wird, muss sterben Richtlinie Dynamischer Speicher Zu jedem new gibt es ein passendes delete!

88 Wer geboren wird, muss sterben Richtlinie Dynamischer Speicher Zu jedem new gibt es ein passendes delete! Nichtbeachtung führt zu Speicherlecks:

89 Wer geboren wird, muss sterben Richtlinie Dynamischer Speicher Zu jedem new gibt es ein passendes delete! Nichtbeachtung führt zu Speicherlecks: Alte Objekte, die den Speicher blockieren...

90 664 Wer geboren wird, muss sterben... Richtlinie Dynamischer Speicher Zu jedem new gibt es ein passendes delete! Nichtbeachtung führt zu Speicherlecks: Alte Objekte, die den Speicher blockieren bis er irgendwann voll ist (heap overflow)

91 Weiter mit dem Stapel: pop() 665 void pop() { assert (!empty()); list_node* p = top_node; top_node = top_node->next; delete p; top_node 1 5 6

92 Weiter mit dem Stapel: pop() void pop() { assert (!empty()); list_node* p = top_node; top_node = top_node->next; delete p; top_node p

94 Weiter mit dem Stapel: pop() void pop() { assert (!empty()); list_node* p = top_node; top_node = top_node->next; delete p; Abkürzung für (*top_node).next top_node p

96 Stapel traversieren: print() void print (std::ostream& o) const { const list_node* p = top_node; while (p!= 0) { o << p->key << " "; p = p->next; top_node

97 Stapel traversieren: print() void print (std::ostream& o) const { const list_node* p = top_node; while (p!= 0) { o << p->key << " "; p = p->next; top_node p

98 Stapel traversieren: print() void print (std::ostream& o) const { const list_node* p = top_node; while (p!= 0) { o << p->key << " "; // 1 p = p->next; top_node p

99 Stapel traversieren: print() void print (std::ostream& o) const { const list_node* p = top_node; while (p!= 0) { o << p->key << " "; // 1 p = p->next; top_node p

100 Stapel traversieren: print() void print (std::ostream& o) const { const list_node* p = top_node; while (p!= 0) { o << p->key << " "; // 1 5 p = p->next; top_node p

101 Stapel traversieren: print() void print (std::ostream& o) const { const list_node* p = top_node; while (p!= 0) { o << p->key << " "; // 1 5 p = p->next; top_node p

102 Stapel traversieren: print() void print (std::ostream& o) const { const list_node* p = top_node; while (p!= 0) { o << p->key << " "; // p = p->next; top_node p

103 Stapel traversieren: print() void print (std::ostream& o) const { const list_node* p = top_node; while (p!= 0) { o << p->key << " "; // p = p->next; top_node p

104 667 Stapel ausgeben: class stack { public: void push (int value) { void print (std::ostream& o) const {... private: list_node top_node; ; operator<<

105 667 Stapel ausgeben: class stack { public: void push (int value) { void print (std::ostream& o) const {... private: list_node top_node; ; operator<< // POST: s is written to o std::ostream& operator<< (std::ostream& o, const stack& s) { s.print (o); return o;

106 Leerer Stapel 668 stack() // default constructor : top_node (0) {

107 Leerer Stapel, empty() 668 stack() // default constructor : top_node (0) { bool empty () const { return top_node == 0;

108 Leerer Stapel, empty(), top() 668 stack() // default constructor : top_node (0) { bool empty () const { return top_node == 0; int top () const { assert (!empty()); return top_node >key;

109 Stapel fertig? 669 stack s1; s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; stack s2 = s1; std::cout << s2 << "\n"; s1.pop (); std::cout << s1 << "\n"; s2.pop ();

113 Stapel fertig? 669 stack s1; s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // stack s2 = s1; std::cout << s2 << "\n"; s1.pop (); std::cout << s1 << "\n"; s2.pop ();

114 Stapel fertig? 669 stack s1; s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // stack s2 = s1; std::cout << s2 << "\n"; s1.pop (); std::cout << s1 << "\n"; s2.pop ();

115 Stapel fertig? 669 stack s1; s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; s2.pop ();

116 Stapel fertig? 669 stack s1; s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; s2.pop ();

117 Stapel fertig? 669 stack s1; s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop ();

118 Stapel fertig? 669 stack s1; s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop ();

119 Stapel fertig? 669 stack s1; s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop (); // Oops, Programmabsturz!

120 Stapel fertig? Offenbar noch nicht stack s1; s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop (); // Oops, Programmabsturz!

121 Was ist hier schiefgegangen? 670 s stack s2 = s1; std::cout << s2 << "\n"; s1.pop (); std::cout << s1 << "\n"; s2.pop ();

122 Was ist hier schiefgegangen? 670 s s2 Memberweise Initialisierung:... nur den top_node-zeiger stack s2 = s1; std::cout << s2 << "\n"; kopiert s1.pop (); std::cout << s1 << "\n"; s2.pop ();

123 Was ist hier schiefgegangen? 670 s1 s stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; s2.pop ();

124 Was ist hier schiefgegangen? 670 s1 s stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; s2.pop ();

125 Was ist hier schiefgegangen? 670 s1 s stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop ();

126 670 Was ist hier schiefgegangen? s1 s Zeiger auf Leiche!... stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop ();

127 670 Was ist hier schiefgegangen? s1 s Zeiger auf Leiche!... stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop (); // Oops, Programmabsturz!

128 Wir brauchen eine echte Kopie! 671 s stack s2 = s1; std::cout << s2 << "\n"; s1.pop (); std::cout << s1 << "\n"; s2.pop ();

129 Wir brauchen eine echte Kopie! 671 s s stack s2 = s1; std::cout << s2 << "\n"; s1.pop (); std::cout << s1 << "\n"; s2.pop ();

130 Wir brauchen eine echte Kopie! 671 s s stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; s2.pop ();

131 Wir brauchen eine echte Kopie! 671 s s stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; s2.pop ();

132 Wir brauchen eine echte Kopie! 671 s s stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop ();

133 Wir brauchen eine echte Kopie! 671 s s stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop ();

134 Wir brauchen eine echte Kopie! 671 s s stack s2 = s1; std::cout << s2 << "\n"; // s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop (); // ok

135 673 Mit dem Copy-Konstruktor klappt s! Hier wird eine Kopierfunktion des list_node benutzt: // POST: this is initialized with a copy of s stack (const stack& s) : top_node (0) { if (s.top_node!= 0) top_node = s.top_node->copy(); s *this

136 673 Mit dem Copy-Konstruktor klappt s! Hier wird eine Kopierfunktion des list_node benutzt: // POST: this is initialized with a copy of s stack (const stack& s) : top_node (0) { if (s.top_node!= 0) top_node = s.top_node->copy(); s *this 2 3 1

137 Die (rekursive) Kopierfunktion von list node 674 // POST: pointer to a copy of the list starting // at this is returned list_node copy () const { if (next!= 0) return new list_node (key, next->copy()); else return new list_node (key, 0); *this (list_node) 2 3 1

138 Die (rekursive) Kopierfunktion von list node 674 // POST: pointer to a copy of the list starting // at this is returned list_node copy () const { if (next!= 0) return new list_node (key, next->copy()); else return new list_node (key, 0); *this (list_node)

139 Die (rekursive) Kopierfunktion von list node 674 // POST: pointer to a copy of the list starting // at this is returned list_node copy () const { if (next!= 0) return new list_node (key, next->copy()); else return new list_node (key, 0); *this (list_node)

140 Initialisierung Zuweisung! 675 stack s1; s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // stack s2 = s1; // Initialisierung s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop (); // ok: Copy-Konstruktor!

141 Initialisierung Zuweisung! 675 stack s1; s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // stack s2; s2 = s1; // Zuweisung s1.pop (); std::cout << s1 << "\n"; // 3 1 s2.pop (); // Oops, Programmabsturz!

142 677 Mit dem Zuweisungsoperator klappt s! Hier wird eine Aufräumfunktion des list_node benutzt: // POST: this (left operand) is getting a copy of s (right operand) stack& operator= (const stack& s) { if (top_node!= s.top_node) { // keine Selbtszuweisung! if (top_node!= 0) { top_node->clear(); // loesche Knoten in this top_node = 0; if (s.top_node!= 0) top_node = s.top_node->copy(); // kopiere s nach this return *this; // Rueckgabe als L Wert (Konvention)

147 Die (rekursive) Aufräumfunktion des list node 678 // POST: the list starting at this is deleted void clear () { if (next!= 0) next->clear(); delete this; *this 2 3 1

150 Zombie-Elemente 679 { stack s1; // local variable s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // // s1 has died (become invalid)...

151 Zombie-Elemente 679 { stack s1; // local variable s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // // s1 has died (become invalid) aber die drei Elemente des Stapels s1 leben weiter (Speicherleck)!

152 Zombie-Elemente 679 { stack s1; // local variable s1.push (1); s1.push (3); s1.push (2); std::cout << s1 << "\n"; // // s1 has died (become invalid) aber die drei Elemente des Stapels s1 leben weiter (Speicherleck)! Sie sollten zusammen mit s1 aufgeräumt werden!

153 Mit dem Destruktor klappt s! 681 // POST: the dynamic memory of this is deleted ~stack() { if (top_node!= 0) top_node >clear();

154 Mit dem Destruktor klappt s! 681 // POST: the dynamic memory of this is deleted ~stack() { if (top_node!= 0) top_node >clear(); löscht automatisch alle Stapelemente, wenn der Stapel ungültig wird

155 681 Mit dem Destruktor klappt s! // POST: the dynamic memory of this is deleted ~stack() { if (top_node!= 0) top_node >clear(); löscht automatisch alle Stapelemente, wenn der Stapel ungültig wird Unsere Stapel-Klasse befolgt jetzt die Richtlinie Dynamischer Speicher!

156 Dynamischer Datentyp 682 Typ, der dynamischen Speicher verwaltet (z.b. unsere Klasse für Stapel)

157 Dynamischer Datentyp 682 Typ, der dynamischen Speicher verwaltet (z.b. unsere Klasse für Stapel) Andere Anwendungen: Listen (mit Einfügen und Löschen in der Mitte ) Bäume (nächste Woche) Warteschlangen Graphen

158 Dynamischer Datentyp 682 Typ, der dynamischen Speicher verwaltet (z.b. unsere Klasse für Stapel) Mindestfunktionalität: Konstruktoren Destruktor Copy-Konstruktor Zuweisungsoperator Dreierregel: definiert eine Klasse eines davon, so sollte sie auch die anderen zwei definieren!