1 / 84

Konstruktoren / Destruktoren

Konstruktoren / Destruktoren. In C: Initialsieren einer Variable, z.B: int i = 10;. In C++: Initialsieren eines Objekts. Dies geschieht durch den sogenannten Konstruktor.

hadassah-rivas
Download Presentation

Konstruktoren / Destruktoren

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Konstruktoren / Destruktoren

  2. In C: Initialsieren einer Variable, z.B: int i = 10;

  3. In C++: Initialsieren eines Objekts

  4. Dies geschieht durch den sogenannten Konstruktor. Dies ist eine spezielle Methode in der Klasse mit dem gleichen Namen wie die Klasse, aber ohne einen Rückgabewert (auch nichtvoid).

  5. Ein Konstruktor kann (wie jede andere Funktion auch) überladen sein, d.h. es kann mehrere Konstruktoren mit dem gleichen Namen, aber verschiedenen Parametern -bezogen auf die Anzahl und den Datentyp - geben

  6. Konstruktor wird immer dann aufgerufen, wenn ein Objekt der Klasse instanziert wird.

  7. Aufgabe: Erzeugen Sie für die Klasse Punkt (in einem Koordinatensystem) einen Konstruktor, einmal mit keinem bzw. mit zwei Parametern.

  8. class Punkt{ private: int x; int y; public: Punkt(); Punkt(int xx, int yy); void set_xy(int xx, int yy); int get_x(); int get_y(); }; // class Punkt Konstruktor hat keinen (auch nicht void) Rückgabewert. Konstruktor kann überladen sein

  9. Punkt::Punkt(){ x = 0; y = 1; } Punkt::Punkt(int xx, int yy){ set_xy(xx, yy); } void Punkt::set_xy(int xx, int yy){ x = xx; y = yy; } // gleich geht es weiter. ...

  10. int Punkt:: get_x(){ return(x); } int Punkt::get_y(){ return(y); }

  11. Beispiele für das Instanzieren von Objekten:

  12. class Punkt{ //siehe oben }; int main(){ int kx, ky; Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); } Konstruktor ohne Parameter wird ohne Klammern aufgerufen Konstruktor mit Parameter wird mit Klammern aufgerufen

  13. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  14. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  15. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  16. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  17. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  18. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  19. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  20. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  21. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  22. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  23. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  24. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  25. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  26. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  27. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  28. class Punkt{ //siehe oben }; int main(){ Punkt p; Punkt q(3, 7); kx = p.get_x(); ky = p.get_y(); kx = q.get_x(); ky = q.get_y(); p.set_xy(2,4); q.set_xy(6,8); }

  29. Mögliche Belegung im Arbeitsspeicher:(Annahme: Compiler benötigt 4 Byte für eine Integer-Variable p.x 2 0400 p p.y 4 0404 q.x 6 0408 q q.y 8 0412 ...

  30. Ein Konstruktor ohne Argumente (Parameter) wie z.B. Punkt() heisst Standard-Konstruktor.

  31. Implementiert der Programmierer für eine Klasse überhaupt keinen Konstruktor, dann erzeugt der Compiler automatisch einen Standard-Konstruktor, der keine Anweisungen besitzt.

  32. Hat der Programmierer dagegen mindestens einen Konstruktor (egal mit 0, 1, 2,..., n Parametern) implementiert, erzeugt der Compiler keinen Standard-Konstruktor.

  33. Beispiel:

  34. class Nagel{ private: int laenge; public: void set(int l); }; void Nagel::set(int l){ laenge = l; } int main(){ Nagel n; } Ja, weil der Compiler automatisch einen Standard-Konstruktor erzeugt. Wie lang ist der Nagel, d.h. welchen Wert hat n.laenge ? Man weiß es nicht, weil der vom Compiler erzeugte Standard-Compiler keine Anweisung besitzt. Ist dies korrekt ? Warum ?

  35. Beispiel:

  36. class Nagel{ private: int laenge; public: Nagel(int l) void set(int l); }; void Nagel::set(int l){ laenge = l; } Nagel::Nagel(int l){ set(l); }

  37. int main(){ Nagel n; } Nein, weil der Compiler keinen Standard-Konstruktor erzeugt. Ein Standard-Konstruktor wird aber beim Instanzieren bei: Nagel n; benötigt ! Ist dies korrekt ? Warum ?

  38. Konstruktoren: Wie wird sichergestellt, dass ein Objekt beim Instanzieren auf jeden Fall initialisiert wird, auch wenn der Programmierer keinen Konstruktor implementiert ?

  39. Der Compiler erzeugt einen Standard-Konstruktor.

  40. Problem mit Konstruktoren: Objektenthält als Attribut wieder ein Objekt. Wie ist sichergestellt, dass dieses (eingelagerte) Objekt auch initialisiert wird, selbst wenn der Programmierer es vergisst ?

  41. Beispiel:

  42. class Punkt{ // wie früher }; class Kreis{ private: Punkt mp; int r; public: Kreis(int xm, int ym, int a); }; //class Kreis Kreis::Kreis(int xm, int ym, int a){ r = a; } Der Radius ist eine Integer-Zahl Der Mittelpunkt ist ein Punkt:mp hat den Klassentyp (d.h. Typ ist eine Klasse) Punkt Was passiert, wenn der Programmierer den Punkt mp nicht im Konstruktor Kreis initialisiert ?

  43. class Punkt{ // wie früher }; class Kreis{ private: Punkt mp; int r; public: Kreis(int xm, int ym, int a); }; //class Kreis Unabhängig vom Programmierer werden die eingelagerten Objekte auf jeden Fall vor Eintritt in den Funktionskörper des umgebenden Konstruktors (hier: Kreis) automatisch durch den jeweils zugehörigen Standard-Konstruktor (hier Punkt) jedes eingelagerten Objekts initialisiert.

  44. class Punkt{ // wie früher }; class Kreis{ private: Punkt mp; int r; public: Kreis(int xm, int ym, int a); }; //class Kreis Was passiert also, wenn der Programmierer in der Klasse Punkt noch keinen Standard-Konstruktor, aber einen anderen Konstruktor, egal mit wieviel (1, 2, 3, ...) Parametern, implementiert hat ? Dann erzeugt der Compiler eine Fehlermeldung: Da schon ein Konstruktor existiert, erzeugt der Compiler keinen Standard-Konstruktor mehr. Doch diesen würde er benötigen.

  45. Alternative Möglichkeit der Initialisierung eingelagerter Objekte: In der Initialisierungsliste werden die eingelagerten Objekte initialisiert (durch die zugehörigen Konstruktoren

  46. Beispiel:

  47. class Punkt{ // wie früher }; class Kreis{ private: Punkt mp; int r; public: Kreis(int xm, int ym, int a); }; Kreis::Kreis(int xm, int ym, int a):mp(xm, ym){ r = a; } Durch einen Doppelpunkt gefolgt von der Initialisierungsliste werden die eingelagerten Objekte initialisiert. (durch die zugehörigen Konstruktoren) Dies geschieht vor Eintritt in den Funktionskörper des umgebenden Konstruktors (hier: Kreis)

  48. int main(){ Kreis k1(10,20,30); Kreis k2(9,7,8); } Welche Werte haben? k1.mp.x k1.mp.y k1.r Es wird aufgerufen: k1(10,20,30) --> k1.mp(10,20) also: k1.mp.x: 10 k1.mp.y: 20 k1.r: 30

  49. Mögliche Belegung im Arbeitsspeicher:(Annahme: Compiler benötigt 4 Byte für eine Integer-Variable k1.mp.x 0300 10 k1.mp.y 20 0304 k1 k1.r 0308 30 k2.mp.x 9 0312 k2.mp.y k2 0316 7 k2.r 8 0320 ...

  50. Destruktor

More Related