Jürgen Bayer. OOP mit C++ Von einfachen Klassen über Vererbung zum Polymorphismus

Transkript

1 Jürgen Bayer OOP mit C++ Von einfachen Klassen über Vererbung zum Polymorphismus

2 Inhaltsverzeichnis 1 Einführung 1 1 Die Basis der OOP: Die Klasse Klassen und Strukturen Die Strukturierung einer Anwendung Einfache Klassen und deren Anwendung Grundlagen zur Programmierung von Klassen Objekte statisch erzeugen Objekte dynamisch erzeugen Die Bedeutung des Stack Wie werden Objekte gespeichert? Der this-zeiger Die Sichtbarkeit von Klassenelementen Daten schützen: Die Kapselung Die klassische Kapselung Bessere Kapselung mit Ausnahmen Konstruktoren und Destruktoren Konstruktoren Der Copy-Konstruktor Der Destruktor Assoziationen zwischen Objekten 20 2 Vererbung und Polymorphismus Vererbung Warum Vererbung? Das Beispiel Die Grundlagen der Vererbung Die Neudefinition von Methoden Verwenden geerbter Elemente Die Sichtbarkeit bei der Vererbung Veröffentlichen von privaten und geschützten Elementen in abgeleiteten Klassen Vererbung von Konstruktoren und Destruktoren 36

3 2.10 Polymorphismus und virtuelle Methoden public-, protected- und private-ableitung Mehrfachvererbung 42 3 OOP-Specials Abstrakte Klassen und Methoden Statische Klassenelemente Statische Eigenschaften (Klasseneigenschaften) Statische Methoden (Klassenmethoden) Verschachtelte Klassen Friends Operatoren für Klassen Schnittstellen 59 4 Index 64

4 Dieser Artikel beschreibt die grundlegenden Konzepte der objektorientierten Programmierung (OOP) in C++. Dabei gehe ich einen eher praxisorientierten als theoretischen Weg. In der OOP- Theorie wird vieles diskutiert, was in der Praxis wenig oder oft auch gar keine Bedeutung hat. Diese teilweise sehr theoretischen Themen lasse ich einfach weg. Trotzdem behandelt dieser Artikel die objektorientierte Programmierung recht ausführlich. Ich setze dabei voraus, dass Sie die Grundlagen der OOP und der normalen Programmierung (Variablen, Schleifen, Verzweigungen, Funktionen, Prozeduren etc.) einigermaßen beherrschen und nun die OOP in C++ kennen lernen wollen. Falls Sie die Grundlagen nicht kennen, lesen Sie meinen Online-Artikel OOP-Grundlagen ( In Kapitel 2 erfahren Sie, wie Sie eine Klasse programmieren und aus dieser Klasse Objekte erzeugen. Daneben werden wichtige Basiskonzepte der OOP (wie Kapselung, Konstruktoren und Destruktoren) näher beleuchtet. Ab Kapitel 3 geht es dann ans Eingemachte. Dieses Kapitel beschreibt zwei wichtige Konzepte der OOP, die so genannte Vererbung und den Polymorphismus. In Kapitel 4 werden schließlich einige spezielle Features der OOP, wie z. B. virtuelle Methoden, statische Klassenelemente und Schnittstellen beschrieben, die Sie kennen sollten, wenn Sie die Möglichkeiten der OOP wirklich ausnutzen wollen. Einführung 1

5 C++ erlaubt die Deklaration von Klassen und Strukturen zur Strukturierung eines OOP- Programms. Klassen und Strukturen unterscheiden sich in C++ prinzipiell kaum. In beiden können Sie Eigenschaften und Methoden unterbringen. Für einige Leser werden Methoden in Strukturen (die in klassischen Programmen nur Daten speichern) etwas ungewöhnlich sein. C++ definiert den Begriff Struktur aber etwas anders als gewohnt. Die folgende Auflistung macht die Unterschiede zwischen Klassen und Strukturen deutlich: Klassen werden mit dem Schlüsselwort class deklariert, Strukturen mit struct. Alle Datenfelder in einer Struktur sind öffentlich. Klassen ermöglichen dagegen, dass Datenfelder privat oder geschützt (protected) deklariert werden. Strukturen ermöglichen somit nicht das wichtige Konzept der Kapselung. Strukturen können eigentlich nur deswegen wie einfache Klassen behandelt werden, damit die Umsetzung von C-Quellcode nach C++ vereinfacht wird. Weil Strukturen die wichtige Kapselung nicht unterstützen, sollten Sie stattdessen immer Klassen einsetzen. Strukturen werden in diesem Artikel nicht weiter behandelt. Das folgende Beispiel deklariert eine Struktur zur Speicherung von Personendaten: struct Person /* Datenfelder der Struktur */ string Vorname; string Nachname; ; /* Eine einfache Methode, die den vollen Namen * der Person zurückgibt */ string VollerName() return Vorname + " " + Nachname; Instanzieren und Verwenden einer Struktur: Person p; p.vorname = "Fred Bogus"; p.nachname = "Trumper"; cout << p.vollername() << endl; Größere Programme erfordern eine Strukturierung des Quellcodes. Die Basis der Strukturierung ist in C++ eine Klasse. Über Klassen erreichen Sie, dass Sie Programmcode wiederverwenden können und dass Sie Ihr Programm so strukturieren, dass die Fehlersuche und die Wartung erheblich erleichtert werden. Wenn Sie eine Klasse entwickeln, können Sie entscheiden, ob Sie eine echte Klasse (mit normalen Eigenschaften und Methoden) programmieren, aus der Sie später Instanzen erzeugen, oder ob Sie eine Klasse mit statischen Methoden und Eigenschaften erzeugen wollen. Statische Methoden und Eigenschaften (Klassenmethoden, Klasseneigenschaften) können Sie auch ohne eine Instanz der Klasse aufrufen. Echte Klassen arbeiten echt objektorientiert, Klassen mit statischen Methoden und Eigenschaften simulieren (u. a.) die Module der strukturierten Programmierung. Die Basis der OOP: Die Klasse 2

6 ! "## $" In einer C++-Datei (mit der Endung.cpp) können Sie eine oder mehrere Klassen implementieren. In Visual Studio fügen Sie Ihrem Projekt dazu eine neue cpp-datei über den Befehl NEUE KLASSE im Menü EINFÜGEN hinzu. Visual Studio erzeugt allerdings schon eine cpp- und eine h-datei für die Klasse. Die h-datei (Headerdatei) enthält die Deklaration der Klasse, die cpp-datei enthält die Implementierung der Methoden der Klasse. Sie können Klassen jedoch auch komplett in der cpp- Datei unterbringen und auf die Headerdatei verzichten (indem Sie diese einfach aus dem Projekt entfernen). In einer cpp-datei können Sie eine oder mehrere Klassen unterbringen. In der einfachsten Variante werden die Methoden direkt in der Klasse implementiert: class Kreis /* Eigenschaften */ int Radius; ; /* Methoden */ double Umfang() return * 2 * Radius; double Oberflaeche() return * Radius * Radius; Die Klassendeklaration beginnt immer mit dem Schlüsselwort class, gefolgt vom Namen der Klasse. Das Schlüsselwort public definiert, dass die folgenden Klassenelemente öffentlich sind, also von außen, über eine Instanz dieser Klasse verwendet werden können. Eigenschaften werden wie Variablen, Methoden wie Funktionen deklariert. Methoden können auf alle Elemente einer Klasse zugreifen, wie es im Beispiel mit der Eigenschaft Radius der Fall ist. Wenn Sie ein Objekt dieser Klasse verwenden wollen, müssen Sie dieses Objekt nicht, wie in anderen Sprachen, explizit erzeugen. Eine einfache Deklaration reicht in C++ aus. C++ erzeugt das Objekt dann automatisch: int main(void) /* Variable der Klasse deklarieren, womit gleich * auch ein Objekt erzeugt wird */ Kreis k; /* Radius setzen */ k.radius = 20; /* Fläche berechnen und ausgeben */ cout << "Die Flaeche eines Kreises mit " << k.radius << " mm ist " << k.oberflaeche() << " mm^2"; In der Praxis werden Klassen oft in separaten Dateien deklariert, um diese einfach in anderen Programmen wiederverwenden zu können. Um eine oder mehrere Klassen aus separaten Dateien in ein C++-Programm einbinden zu können, können Sie zwei Wege gehen. Der einfachere ist der, die Die Basis der OOP: Die Klasse 3

7 komplette Klasse einfach in einer cpp-datei zu deklarieren und diese cpp-datei über die #include-anweisung einzubinden: #include <iostream.h> #include "Kreis.cpp" int main(void) Kreis k; k.radius = 20; cout << "Die Flaeche eines Kreises mit " << k.radius << " mm ist " << k.oberflaeche() << " mm^2"; Eine etwas kompliziertere Möglichkeit, Klassen in separaten Dateien zu verwalten, ist das Trennen der Deklaration von der Implementierung. Dazu erzeugen Sie eine Datei mit der Endung.h. Diese Headerdatei erhält denselben Namen wie die eigentliche cpp-datei und wird nur mit der Deklaration der Klasse versehen: /* Datei Kreis.h */ class Kreis int Radius; double Umfang(); double Oberflaeche(); ; Für die Implementierung erzeugen Sie eine gleichnamige Datei mit der Endung.cpp. Diese Datei enthält dann die Implementierung der Methoden. Um die Methoden der u. U. verschiedenen Klassen zu unterscheiden, wird jedem Methodenname der Klassenname, gefolgt von zwei Doppelpunkten, vorangestellt. Die Headerdatei muss in die cpp-datei eingebunden werden, damit der Compiler die zugehörige Klasse erkennen kann: /* Datei Kreis.cpp */ #include "Kreis.h" /* Implementierung der Methoden */ double Kreis::Umfang() return * 2 * Radius; double Kreis::Oberflaeche() return * Radius * Radius; Im eigentlichen Programm binden Sie dann nur die Header-Datei ein: #include <iostream.h> #include "Kreis.h" int main() Kreis k; k.radius = 20; cout << "Die Flaeche eines Kreises mit " << k.radius << " mm ist " << k.oberflaeche() << " mm^2"; Die Basis der OOP: Die Klasse 4

8 Diese Trennung macht dann Sinn, wenn Sie Ihre Klassen in Bibliotheken (mit der Endung.lib) kompilieren und diese Bibliotheken für die eigene Verwendung in einem separaten Ordner speichern. Wenn Sie diese Bibliotheken verwenden wollen, benötigt der Compiler Informationen darüber, welche Klassen und andere Typen in der Bibliothek vorhanden sind. Dazu wird dann die Headerdatei verwendet. Diese müssen Sie in alle Quellcodedateien einbinden, in denen Sie die Klassen (und andere Typen) der Bibliothek verwenden wollen. Wenn Sie eine Bibliothek anderen Programmierern zur Verfügung stellen wollen, müssen Sie auch die Headerdateien mitliefern, damit die anderen Programmierer die Bibliothek überhaupt verwenden können. Dasselbe machen Sie in Ihren C- und C++-Programmen, wenn Sie die Headerdateien der Standardbibliotheken in Ihre Programme einbinden. Die Funktionen, Strukturen, Klassen etc., die Sie dann in Ihren Programmen verwenden, sind üblicherweise in Bibliotheken gespeichert. %&! Statisch erzeugen Sie ein Objekt, indem Sie eine Objektvariable wie eine einfache Variable deklarieren: Kreis k; // statische Erzeugung Statisch bedeutet hier, dass C++ das Objekt auf dem Stack speichert. Der Stack ist ein Speicherbereich, den alle Programme besitzen und auf dem u. A. alle lokalen Variablen einer Funktion oder Methode gespeichert werden. Da der Stack nach der Ausführung der Funktion/Methode wieder automatisch bereinigt wird, werden statische Objekte also automatisch zerstört, wenn die Funktion bzw. Methode beendet ist. Diese statische Erzeugung ist übrigens eine Spezialität von C++. Andere Sprachen, wie Pascal/Delphi, C#, Visual Basic(.NET) und Java kennen keine statisch erzeugten Objekte. In diesen Sprachen werden Objekte immer dynamisch erzeugt. Das Problem bei statischen Objekten ist, dass Sie schon bei der Entwicklung wissen müssen, wie viele Objekte gespeichert werden sollen, weil Sie ja die entsprechende Anzahl an Variablen deklarieren müssen. Für manche Probleme reicht das aber nicht aus. Wollen Sie z. B. ein Programm erzeugen, das einen Stammbaum darstellen soll, können Sie bei der Entwicklung noch gar nicht wissen, wie viele Personen-Objekte der Anwender erzeugen und speichern will. Ein anderes Problem kann sein, dass Ihre Objekte sehr viel Speicher benötigen und so die Maximalgröße des Stack (per Voreinstellung 1 MB) überschritten werden kann. Deshalb ist es in C++ auch möglich, Objekte dynamisch zu erzeugen. %&'#! Für die dynamische Erzeugung von Objekten deklarieren Sie die Objektvariable als Zeiger: Kreis *k; Dann erzeugen Sie das Objekt über den new-operator: k = new Kreis; Dynamisch erzeugte Objekte werden auf dem Heap angelegt. Der Heap ist ein Speicherbereich, der für globale Daten reserviert ist. Auf dem Heap werden außerdem alle Funktionen und Klassen einer Anwendung gespeichert. Die Größe des Heap ist nur durch den im System verfügbaren Speicher begrenzt. So kann Ihre Anwendung während des Programmablaufs (eben dynamisch) nahezu beliebig viele Objekte erzeugen. Das Problem dabei ist lediglich, wie Sie die Objekte referenzieren, weil Sie zur Entwicklungszeit noch nicht wissen können, wie viele Referenzen Sie benötigen. Dafür existieren Die Basis der OOP: Die Klasse 5

9 aber einige einfach handhabbare Lösungen, wie z. B. dynamische Arrays oder Auflistungen (die im Rahmen dieses Artikels aber nicht beschrieben werden können). Objekte, die dynamisch erzeugt wurden, können über eine Dereferenzierung des Zeigers angesprochen werden: (*k).radius = 20; Durchgesetzt hat sich aber die Kurzschreibweise, die mit dem Operator -> arbeitet: k->radius = 20; Dynamisch erzeugt Objekte müssen Sie wie alle dynamisch reservierten Speicherbereiche über die delete-anweisung wieder aus dem Speicher entfernen. Vergessen Sie dies, bleibt das Objekt im Speicher, so lange Ihre Anwendung läuft, und verbraucht unnötig Ressourcen. delete k; ( Der Stack besitzt eine große Bedeutung für ein Programm. Der Stack ist ein spezieller Speicherbereich, den jedes Programm besitzt und der wie ein Stapel arbeitet: Daten werden der Reihe nach oben auf dem Stapel abgelegt und können auch wieder, der Reihe nach, vom Stapel entfernt werden. Der Stack wird (vom Compiler automatisch) über Funktionen angesprochen, die Daten oben auf dem Stapel ablegen, Daten vom Stapel auslesen und vom Stapel löschen. Auf dem Stack werden Daten abgelegt, die einen Funktions- oder Methodenaufruf betreffen. Beim Aufruf der folgenden Funktion, int Add(int x, int y) int result; result = x + y; return result; void main(void) int i = Add(1, 2); cout << I; legt der Compiler die folgenden Daten auf dem Stack an: einen Speicherbereich für den Rückgabewert der Funktion, die Adresse, zu der das Programm nach der Ausführung zurückspringen muss, die Argumente der Funktion, und die lokalen Variablen der Funktion. Abbildung 1.1 stellt den Stack bei der Ausführung der Funktion schematisch dar (der tatsächliche Aufbau hängt vom Compiler und der Aufrufkonvention von Funktionen / Methoden ab). Die Basis der OOP: Die Klasse 6

10 Abbildung 1.1: Der Stack bei der Ausführung einer Funktion Ruft die Funktion eine andere Funktion auf, werden die Daten für diese Funktion einfach oben auf dem Stack abgelegt. Beim Beenden einer Funktion wird der Stackbereich dieser Funktion wieder gelöscht. Was dann genau passiert, hängt vom Compiler und von der Aufrufkonvention der Funktion ab (die für ein Programm eingestellt werden kann). Schematisch können Sie sich den Vorgang folgendermaßen vorstellen: Die Funktion löscht alle Argumente und lokalen Variablen, liest die Rücksprungadresse aus, löscht diese und springt dann zu dieser Adresse zurück. Der Compiler sorgt dafür, dass der Rückgabewert der Funktion dann auch noch aus dem Stack ausgelesen und gelöscht wird, damit dieser in Ausdrücken verwendet werden kann. Der Stack besitzt immer eine festgelegte Maximalgröße. In Visual C++ ist die Voreinstellung (laut einigen Newsgroup-Artikeln 1 MB). Er wird allerdings zunächst mit 4 KB recht klein angelegt und bei Bedarf automatisch in 4 KB-Schritten vergrößert. Sie können die Maximalgröße des Stack und den Vergrößerungswert jedoch auch einstellen (Projekteigenschaften / Register LINK / Kategorie OUTPUT). Wenn zu viele Daten auf dem Stack abgelegt werden, was sehr schnell bei rekursiv aufgerufenen Funktionen / Methoden geschehen kann, resultiert ein Stack-Überlauf. ) * %&+, Wenn Sie wissen, wie Objekte prinzipiell gespeichert werden, können Sie einige Features der OOP, wie beispielsweise den Polymorphismus und virtuellen Methoden, besser verstehen. Eine Instanz einer Klasse besteht prinzipiell nur aus den Datenfeldern der Klasse (außer, wenn die Klasse Inline-Methoden beinhaltet, die innerhalb der Instanz gespeichert werden). Angenommen, ein Programm enthält die folgenden Klassen: Die Basis der OOP: Die Klasse 7

11 class Punkt int x; int y; void set(int x, int y) this->x = x; this->y = y; ; class Kreis int Radius; int Farbe; double Umfang return Radius * 2 * ; ; und erzeugt in main statische Instanzen dieser Klassen, void main(void) Kreis k1; Kreis k2; Punkt p1; k1.radius = 100; k1.farbe = 255; k2.radius = 200; k2.farbe = 1024; p1.set(10, 11); dann legt der Compiler im Stack nur die Werte der Eigenschaften Radius und Farbe der Kreise und die Werte der Eigenschaften x und y des Punktes an. Die Methoden der Klasse werden nur ein einziges Mal im Heap angelegt. Ein Methodenzeiger, der jeder Instanz einer Klasse beigefügt ist, zeigt auf die Adresse der Klasse. Abbildung 1.2: Schematische Darstellung der Speicherung von Objekten und deren Klassen k1, k2 und p1 sind also Variablen, die auf die Adresse zeigen, an der die Eigenschaften des Objekts gespeichert sind. Wenn Sie eine (Nicht-Inline-)Methode eines Objekts aufrufen, verwendet der Compiler den Methodenzeiger der Klasseninstanz und kann darüber die Startadresse der Methoden im Heap ermitteln. Dieses Vorgehen reduziert den Speicherbedarf von Objekten enorm. Die Basis der OOP: Die Klasse 8

12 -./ Damit eine Methode, die ja normalerweise (wenn es keine Inline-Methode ist), die Eigenschaften der aufrufenden Instanz bearbeiten kann, übergibt der Compiler der Methode ein zusätzliches, unsichtbares Argument, den this-zeiger. Dieser Zeiger zeigt auf die Objektinstanz, von der aus der Aufruf erfolgt ist. Wenn Sie in einer Methode auf Eigenschaften oder Datenfelder des Objekts zugreifen oder andere Methoden aufrufen, stellt der Compiler diesen Zeiger implizit vor den Namen des verwendeten Klassenelements, falls dies noch nicht explizit geschehen ist und falls ein entsprechendes Klassenelement gefunden wird. Die Methode Umfang der Kreis-Klasse des vorherigen Beispiels sieht im kompilierten Programmcode demnach so aus: double Umfang(Kreis *this) return this->radius * 2 * ; Über den this-zeiger können Sie immer explizit auf Klassenelemente zugreifen, auch dann, wenn innerhalb der Methode gleichnamige lokale Variablen oder Argumente existieren. Beachten Sie, dass this ein Zeiger ist. Sie müssen also mit einer Dereferenzierung oder mit dem Operator -> zugreifen. ( %$"# Die Elemente einer Klasse können Sie in der Sichtbarkeit einschränken, indem Sie diese Elemente in einen Block einfügen, der mit private:, protected: oder eingeleitet wird: class Demo private: // private Eigenschaften und Methoden protected: // geschützte Eigenschaften und Methoden // öffentliche Eigenschaften und Methoden Tabelle 1.1 beschreibt die Bedeutung der Sichtbarkeitsmodifizierer. Die Bedeutung des protected-blocks wird Ihnen aber wahrscheinlich erst bei der Vererbung klar. Modifizierer private Bedeutung Mit private stellen Sie die Sichtbarkeit eines Elements so ein, dass dieses nur innerhalb der Klasse gilt. Alle Methoden der Klasse können auf private Elemente zugreifen. Von außen können solche Elemente allerdings nicht verwendet werden. Wenn Sie damit eine Eigenschaft deklarieren, handelt es sich im Prinzip dabei um einfache Variablen, die von allen Methoden der Klasse verwendet, aber nicht von außen gesetzt oder gelesen werden können. protected Der Modifizierer protected kennzeichnet Klassenelemente, die zunächst wie private Eigenschaften auftreten, aber bei der Vererbung in abgeleiteten Klassen verwendet werden können (was bei privaten Elementen eben nicht möglich ist). public Elemente, die den Modifizierer public besitzen, können von außen (über eine Referenz auf ein Objekt dieser Klasse oder bei statischen Elementen über den Klassennamen) verwendet werden. Tabelle 1.1: Die Modifizierer für die Sichtbarkeit von Klassenelementen Die Basis der OOP: Die Klasse 9

13 )!+ Die Kapselung ist ein wichtiges Grundkonzept der OOP. Kapselung bedeutet, dass Objekte den Zugriff auf ihre Daten selbst kontrollieren. Besitzt ein Objekt nur einfache Eigenschaften, so kann es den Zugriff auf seine Daten nicht kontrollieren. Ein Programmierer, der dieses Objekt benutzt, kann in die Eigenschaften hineinschreiben, was immer auch zu dem Datentyp der Eigenschaften passt. Das kann dazu führen, dass das Objekt ungültige Daten speichert und damit u. U. beim Aufruf von Methoden fehlerhaft reagiert. Stellen Sie sich ein Objekt zum flexiblen Drucken von Texten und Grafiken vor. Dieses Objekt besitzt Eigenschaften zum Einstellen der Ränder, die beim Drucken berücksichtigt werden. Stellt der Programmierer diese Eigenschaften z. B. auf negative Werte ein, wird der Ausdruck wahrscheinlich etwas konfus aussehen. Kontrolliert das Objekt jedoch den Zugriff auf diese Eigenschaften, so ist ein fehlerhaftes Einstellen (wie z. B. auf negative Werte) erst gar nicht möglich. Das Objekt kann dann unter allen Umständen sicher arbeiten. Kapselung kann auf zwei Arten realisiert werden. Die ältere Methode ist, die Daten des Objekts einfach immer in privaten Variablen innerhalb der Klasse zu speichern und für den Zugriff auf diese Daten jeweils eine Methode zum Schreiben des Werts und eine zum Lesen des Werts zur Verfügung zu stellen. Diese Methoden können dann den Zugriff auf die Daten sehr gut kontrollieren. Eine andere, modernere Variante stellen einige Programmiersprachen zur Verfügung: Über so genannte Property-Prozeduren können Sie Eigenschaften implementieren, die nach außen wie eine normale Eigenschaft beschrieben und gelesen werden können, aber intern in Wirklichkeit aus einer Schreib- und einer Lesemethode bestehen. Der Vorteil einer solchen speziellen Eigenschaft ist, dass die Verwendung sehr einfach ist, weil einfach nur Werte hineingeschrieben und gelesen werden. Und trotzdem ist die Eigenschaft in der Lage, die geschriebenen oder gelesenen Daten zu kontrollieren. C++ kennt leider keine Property-Prozeduren, Sie müssen die Kapselung also über eigene Methoden implementieren. ) + Die klassische Kapselung arbeitet so, dass die Daten des Objekts grundsätzlich in privaten Variablen gespeichert werden und zum Zugriff auf diese Daten eine Lese- und eine Schreibmethode erzeugt werden. Die Schreibmethode kann entscheiden, welche Daten in das Objekt geschrieben werden, die Lesemethode entscheidet, wie die Daten zurückgegeben werden. Das folgende Beispiel demonstriert dieses Vorgehen für eine Personenklasse, die den Zugriff auf das Geburtsdatum der Person kontrolliert. Das folgende Beispiel implementiert eine Kreis-Klasse, die den Zugriff auf die Radius-Eigenschaft kontrolliert: class Kreis private: // der Radius int radius; // Methode zum Setzen des Radius void setradius(int wert) if (wert > 0) this->radius = wert; else this->radius = 0; // Methode zum Lesen des Radius int getradius() return this->radius; // Methode zur Berechnung des Umfangs double getumfang() Die Basis der OOP: Die Klasse 10

14 ; return this->radius * 2 * ; Die Kapselung ist in diesem Beispiel klar sichtbar an der Eigenschaft radius, deren Schreibmethode überprüft, ob der übergebene neue Radius größer als 0 ist. Die Lesemethode getradius macht zwar nichts weiter, als den Radius zurückzugeben, die zusätzliche Lesemethode getumfang demonstriert aber, dass es auch Sinn macht, den lesenden Zugriff auf die Daten zu steuern. ) + # # Etwas ungeschickt an dem vorherigen Beispiel ist, dass der aufrufende Programmierer nicht unbedingt mitbekommt, dass die Schreibmethode fehlgeschlagen ist, wenn er einen ungültigen Radius übergibt. Er erkennt dies höchstens daran, dass der Radius nun 0 beträgt, wenn die Methode einen ungültigen Radius zurückweist. Eine Methode, die den Zugriff auf die Daten kontrolliert, sollte dem Programmierer das Fehlschlagen der Methode aber so mitteilen, dass dieser gezwungen ist, das Fehlschlagen zu quittieren. Dafür stellen die verschiedenen Sprachen so genannte Ausnahmen (englisch: Exceptions) zur Verfügung, die der Entwickler der Klasse im Fehlerfall aufrufen kann und die dann im Programm zu einem Laufzeitfehler führen, wenn der Fehlerfall eintritt. Das folgende Beispiel demonstriert, wie in C++ eine Ausnahme ausgelöst wird: class Kreis private: // der Radius int radius; // Methode zum Setzen des Radius void setradius(int wert) if (wert > 0) this->radius = wert; else // Ausnahme "werfen" throw int(1001); ; // Methode zum Lesen des Radius int getradius() return this->radius; // Methode zur Berechnung des Umfangs double getumfang() return this->radius * 2 * ; Dieses Beispiel "wirft" eine Ausnahme vom Typ int. Beim Werfen einer Ausnahme wird eine Instanz eines Datentyps erzeugt und diese direkt (in den Klammern) initialisiert. Die Methode bricht an der Stelle, an der die Ausnahme geworfen wird, ab und gibt die Kontrolle an die aufrufende Methode/Funktion weiter. Diese kann die Ausnahme abfangen. Wird die Ausnahme dort nicht abgefangen, wird sie in der Aufrufreihenfolge weiter nach oben gereicht und kann dort Die Basis der OOP: Die Klasse 11

15 abgefangen werden. Wird eine Ausnahme schließlich nicht behandelt, führt das zur Anzeige einer Fehlermeldung und zum Absturz des Programms. Abgefangen werden Ausnahmen in try-catch-blöcken. Im try-block werden die Anweisungen untergebracht, die Ausnahmen erzeugen können, der catch-block fängt Ausnahmen ab. Sie können mehrere catch-blöcke einrichten, die verschiedene Typen von Ausnahmen abfangen. Das folgende Beispiel fängt Ausnahmen vom Typ int ab: int main(int argc, char* argv[]) // Kreis-Objekt erzeugen und verwenden Kreis k; // Die eventuelle Ausnahme wird abgefangen try k.setradius(-100); cout << "Ein Kreis mit " << k.getradius() << " mm Radius besitzt einen Umfang von " << k.getumfang() << " mm." << endl; catch (int i) cout << "Fehler Nummer " << i << endl; return 0; Ausnahmen sollten einen eigenen Typ besitzen, damit mehr als nur eine Fehlernummer ausgelesen werden kann. Für eine eigene Ausnahme benötigen Sie eine Klasse, die Sie allerdings schon mit einem Konstruktor erweitern müssen, damit beim Werfen der Ausnahme Werte übergeben werden können. Das folgende Beispiel deklariert eine Klasse WertAusnahme, die dann von der setradius- Methode geworfen wird, wenn der Radius ungültig ist: // Klasse für die Ausnahme class WertAusnahme string Meldung; int Nummer; ; // Der Konstruktor WertAusnahme(string meldung, int nummer) this->meldung = meldung; this->nummer = nummer; // Klasse für einen Kreis class Kreis private: // der Radius int radius; // Methode zum Setzen des Radius void setradius(int wert) if (wert > 0) this->radius = wert; else // Ausnahme "werfen" throw WertAusnahme("Der Radius kann nicht " + Die Basis der OOP: Die Klasse 12

16 "kleiner/gleich 0 sein", 1001); // Methode zum Lesen des Radius int getradius() return this->radius; // Methode zur Berechnung des Umfangs double getumfang() return this->radius * 2 * ; ; Beim Abfangen der Ausnahme kann nun zusätzlich eine Meldung ausgegeben werden: int main(int argc, char* argv[]) // Kreis-Objekt erzeugen und verwenden Kreis k; // Die eventuelle Ausnahme wird abgefangen try k.setradius(-100); cout << "Ein Kreis mit " << k.getradius() << " mm Radius besitzt einen Umfang von " << k.getumfang() << " mm." << endl; catch (WertAusnahme w) cout << "Fehler Nummer " << w.nummer << ": " << w.meldung << endl; return 0; Sie können mehrere catch-blöcke für unterschiedliche Ausnahmen hintereinander deklarieren. Wenn Sie in einem Block alle noch nicht abgefangenen Ausnahmen abfangen wollen, verwenden Sie die Syntax catch(...): try k.setradius(-100); cout << "Ein Kreis mit " << k.getradius() << " mm Radius besitzt einen Umfang von " << k.getumfang() << " mm." << endl; // Die Wert-Ausnahme abfangen catch (WertAusnahme w) cout << "Fehler Nummer " << w.nummer << ": " << w.meldung << endl; // Alle anderen Ausnahmen abfangen catch (...) cout << "Unbekannte Ausnahme aufgetreten." << endl; Wie Sie dem Beispiel entnehmen können, können Sie dann leider nichts weiter über die Ausnahme aussagen, als dass eine unbekannte Ausnahme eingetreten ist. Nun können Sie sich auch erklären, warum manche Programme solche unbekannten Ausnahmen oder Fehler meldet. Die Basis der OOP: Die Klasse 13

17 - " " " - " " Ein Konstruktor ist eine spezielle Methode, die automatisch aufgerufen wird, wenn das Objekt erzeugt wird. Auch wenn Sie keinen eigenen Konstruktor in die Klasse integrieren, besitzt diese immer einen Konstruktor: In Klassen, die keinen Konstruktor enthalten, fügt der Compiler automatisch einen parameterlosen Standardkonstruktor ein. Dieser Konstruktor wird implizit verwendet, wenn Sie eine Instanz einer Klasse ohne Argumente erzeugen: Kreis k; // Implizit wird der Standardkonstruktor verwendet Der vom Compiler eingefügte Standardkonstruktor besitzt für Programmierer nur die eine Bedeutung, dass Instanzen damit ohne Übergabe von Argumenten erzeugt werden können. Sie können aber auch eigene Konstruktoren in die Klasse implementieren, mit denen Sie ein Objekt direkt bei dessen Erzeugung initialisieren können. Bei einer Personenklasse wäre es z. B. sinnvoll, einem Personenobjekt bei der Erzeugung gleich den Vornamen und den Nachnamen der Person zu übergeben. In C++ wird ein Konstruktor ähnlich einer Methode deklariert. Weil ein Konstruktor allerdings nie einen Wert zurückgibt, wird kein Rückgabetyp angegeben (auch nicht void). Außerdem muss der Name des Konstruktors derselbe sein, wie der der Klasse. Konstruktoren müssen im public- Bereich der Klasse deklariert werden, damit diese von außen verwendet werden können. Konstruktoren können wie Methoden überladen werden. Das folgende Beispiel demonstriert dies anhand einer Klasse zur Speicherung von Personendaten: class Person string Vorname; string Nachname; string Ort; ; /* Dem ersten Konstruktor wird der Vorname und * der Nachname der Person übergeben */ Person(string vorname, string nachname) this->vorname = vorname; this->nachname = nachname; this->ort = ""; /* Dem zweiten Konstruktor wird zusätzlich * der Ort übergeben */ Person(string vorname, string nachname, string ort) this->vorname = vorname; this->nachname = nachname; this->ort = ort; Die Basis der OOP: Die Klasse 14

18 Wenn Sie nun Objekte dieser Klasse erzeugen, müssen Sie einen der beiden Konstruktoren verwenden: /* Eine Person mit dem ersten Konstruktor erzeugen */ Person p1("donald", "Duck"); /* Eine Person mit dem zweiten Konstruktor erzeugen */ Person p2 ("Fred Bogus", "Trumper", "New York"); Wenn Sie einen eigenen Konstruktor in eine Klasse einfügen, erzeugt der Compiler den Standardkonstruktor nicht mehr. Die Erzeugung einer Person ohne Übergabe von Argumenten ist in unserem Beispiel also nicht mehr möglich: Person p3; // lässt der Compiler nicht zu Wenn Sie dies zulassen wollen, müssen Sie einen parameterlosen Konstruktor in die Klasse einfügen: class Person string Vorname; string Nachname; string Ort; /* Parameterloser Standardkonstruktor */ Person()... Dieser Konstruktor muss nichts weiter an Quellcode enthalten. Konstruktoren besitzen normalerweise die Sichtbarkeit public, können aber auch im private oder protected-bereich deklariert werden. public-konstruktoren können als einzige von außen verwendet werden, um ein Objekt dieser Klasse zu erzeugen. Ein privater Konstruktor verhindert, dass ein Programm ein Objekt dieser Klasse mit Hilfe dieses Konstruktors erzeugt. Enthält die Klasse lediglich einen privaten Konstruktor, kann niemand (außer die Klasse selbst über eine statische Methode) von dieser Klasse Instanzen erzeugen. Üblicherweise wird ein solcher Konstruktor bei Klassen verwendet, die nur statische Elemente enthalten, und von denen deshalb keine Instanzen erzeugt werden sollen. private Konstruktoren verwendet man auch häufig in Zusammenhang mit friend- Deklarationen, um die Erzeugung eines Objekts von außen zu verhindern und nur von anderen Klassen aus zu ermöglichen. protected-konstruktoren verhalten sich ähnlich, können aber im Gegensatz zu privaten Konstruktoren von abgeleiteten Klassen in deren Konstruktoren aufgerufen werden. Mit privaten und geschützten Konstruktoren können Sie einige spezielle Techniken programmieren. So können Sie z. B. eine Instanzierung einer Klasse nur über eine statische Methode der Klasse ermöglichen, damit Sie die Anzahl der erzeugten Instanzen kontrollieren können. Konstruktoren werden nicht nur dazu verwendet, das Objekt zu initialisieren. Sie können in einem Konstruktor z. B. auch eine Datei oder eine Verbindung zu einer Datenbank öffnen, die Ihre Klasse benötigt. Das String-Beispiel beim Copy-Konstruktor demonstriert dies. Die Basis der OOP: Die Klasse 15

19 - 0"+'." " Jede C++-Klasse besitzt neben den normalen Konstruktoren auch einen Copy-Konstruktor. Ein Copy-Konstruktor besitzt ein Referenzargument vom Typ der Klasse und kopiert die Eigenschaften des übergebenen Objekts in die Eigenschaften der Instanz, für die der Copy-Konstruktor ausgerufen wird. Wenn Sie keinen eigenen Copy-Konstruktor in die Klasse integrieren, fügt der Compiler einen solchen automatisch ein (der aber zu Problemen führen kann, wie Sie gleich noch sehen). Der Copy-Konstruktor wird implizit verwendet, wenn Sie eine Instanz einer Klasse auf eine Variable zuweisen: // Eine Person über den Copy-Konstruktor erzeugen Person p2 = p1; // hier wird der Copy-Konstruktor aufgerufen Der Compiler erzeugt dann eine Kopie des Objekts. Nach der Ausführung dieser Anweisung existieren zwei Person-Objekte, die zwar dieselben Werte speichern, aber dennoch separate, individuelle Objekte sind. Das unterscheidet C++ von anderen Sprachen, die nur dynamische Objekte kennen. Wenn Sie in einer anderen Sprache eine Objektvariable einer anderen zuweisen, wird die Referenz kopiert, nicht die Werte. In diesen Sprachen würde nach der Ausführung der Anweisung im Beispiel oben beide Variablen dasselbe Objekt referenzieren! Wenn Sie in C++ allerdings Objekte dynamisch erzeugen und einen Objektzeiger einem anderen zuweisen, wird der Copy-Konstruktor nicht aufgerufen: // Eine Person dynamisch erzeugen... Person *p3 = new Person("Merril", "Overturf", "Wien"); //... und einer anderen Referenz zuweisen. // Der Copy-Konstruktor wird nicht aufgerufen Person *p4 = p3; Nach der Ausführung der letzten Anweisung zeigen beide Zeiger auf dasselbe Objekt. Eine Veränderung des Objekts über p3 betrifft dann auch p4. Über einen direkten Aufruf des Copy-Konstruktors können Sie auch dynamisch Kopien von Objekten erzeugen: Person *p5 = new Person(p1); // direkter Aufruf des Copy-Konstruktors Merken können Sie sich, dass immer, wenn Sie ein Objekt an eine Variable oder an ein Argument übergeben, die keine Zeiger und keine Referenzen sind, der Copy- Konstruktor aufgerufen und folglich eine Kopie des Objekts erzeugt wird. Diese Kopie wird auch als flache Kopie bezeichnet (das Kopieren der Referenzen heißt tiefe Kopie). Die Basis der OOP: Die Klasse 16

20 Wenn Sie eine Methode deklarieren, die ein Objekt als Argument besitzt, wird das Objekt über den Copy-Konstruktor kopiert, wenn das Argument nicht als Zeiger oder Referenz deklariert ist: void Demo1(Person p) // Der Copy-Konstruktor erzeugt eine Kopie // Eine Veränderung des Objekts wird natürlich // dann nicht nach außen gegeben p.vorname = "Donald"; p.nachname = "Duck"; cout << "p in der Funktion Demo2: " << p.vorname << " " << p.nachname << endl; Veränderungen des Objekts innerhalb der Funktion/Methode werden dann natürlich nicht im übergebenen Objekt sichtbar. Ist das Argument allerdings als Zeiger oder Referenz deklariert, wird keine flache Kopie erzeugt: void Demo2(Person &p) // Eine Veränderung des Objekts wird // nach außen gegeben p.vorname = "Donald"; p.nachname = "Duck"; cout << "p in der Funktion Demo2: " << p.vorname << " " << p.nachname << endl; Eine Veränderung des Objekts betrifft dann auch das übergebene Objekt. Sie können einen eigenen Copy-Konstruktor in Ihre Klassen einfügen. Dieser erhält als einziges Argument eine Referenz auf eine Instanz der Klasse: Person(Person &p) this->vorname = p.vorname; this->nachname = p.nachname; this->ort = p.ort; cout << "Copy-Konstruktor wurde aufgerufen." << endl; Sinnvoll ist dies immer dann, wenn Ihre Klassen mit dynamischen Speicherbereichen arbeiten. Der Default-Copy-Konstruktor erzeugt nur eine einfache Kopie der Daten der Klasse. Dabei werden nur die Zeiger der dynamischen Speicherbereiche kopiert. Das führt eigentlich immer zu Problemen. Das folgende Beispiel demonstriert diese Problematik. Eine eigene String-Klasse soll Zeichenketten verwalten: class String private: char *c_str; // Methode zum Setzen void setstring(const char *neuerstring) if (c_str!= NULL) delete c_str; c_str = new char[strlen(neuerstring) + 1]; strcpy(c_str, neuerstring); // Default-Konstruktor String() // Der C-String-Zeiger wird auf einen wohldefinierten Wert // gesetzt, der vor der Manipulation des Strings abgefragt Die Basis der OOP: Die Klasse 17

21 // werden kann. c_str = NULL; ; // Konstruktor mit C-String-Argument String(char *neuerstring) c_str = NULL; // wird von setstring abgefragt! setstring(neuerstring); // Destruktor virtual ~String() // Freigabe des Speichers if (c_str!= NULL) delete c_str; // Methode zum Lesen. // Diese Methode ist mit dem Modifizierer const versehen, // damit der gespeicherte C-String nicht über den // zurückgegebenen Zeiger verändert werden kann. // Das vermeidet eventuelle Probleme, die bei einer // Erweiterung der Klasse ansonsten auftreten könnten. const char *getstring() return c_str; Wenn nun ein Objekt dieser Klasse über den Copy-Konstruktor erzeugt wird, zeigt der char- Zeiger in beiden Instanzen auf denselben Speicherbereich: void main(void) String *s1 = new String("Hello Copy-Konstruktor-Problem"); // Copy-Konstruktor wird aufgerufen String *s2 = new String(*s1); cout << "String 1: " << s1->getstring() << endl; cout << "String 2: " << s2->getstring() << endl; Wird nun einer der beiden Strings gelöscht, delete s1; so zeigt der zweite String auf einen ungültigen Speicherbereich cout << "String 2 nach dem Löschen von String 1: " << s2->getstring() << endl; und gibt nur noch Speichermüll aus. Um dieses Problem zu vermeiden müssen Sie bei allen Klassen, die dynamischen Speicher anfordern und verwenden, einen Copy-Konstruktor erzeugen, der neben der Kopie der statischen Daten der Klasse den dynamischen Speicher für die neue Instanz separat reserviert und dessen Inhalt kopiert. Die Basis der OOP: Die Klasse 18

22 Bei der String-Klasse könnte dieser Konstruktor so aussehen: String(String &quelle) // Den Zeiger auf den C-String der übergebenen Instanz // zwischenspeichern, damit die Methode getstring nur // einmal aufgerufen werden muss. const char *temp = quelle.getstring(); // Überprüfen, ob die übergebene Instanz auch einen // gültigen String verwaltet if (temp!= NULL) // Kopieren des C-Strings in einen eigenen, // neuen Speicherbereich c_str = new char[strlen(temp) + 1]; strcpy(c_str, temp); else // die übergebene Instanz verwaltet keinen String; // den String-Zeiger auf einen definierten Wert setzen c_str = NULL; Die Überprüfung, ob die übergebene String-Instanz einen gültigen String verwaltet, ist notwendig. Ein Programmierer kann eine Instanz dieser Klasse auch über den Default-Konstruktor erzeugen: String s1; und diese Instanz einer anderen zuweisen: String s2 = s1; Ohne die Überprüfung würde der Copy-Konstruktor versuchen, die Länge des C-Strings zu ermitteln und dort mit einer Speicherverletzung abstürzen (weil der Zeiger des C-Strings NULL speichert). Die Basis der OOP: Die Klasse 19

23 - " Der Destruktor eines Objekts wird aufgerufen, wenn das Objekt zerstört wird. Im Destruktor können Sie Aufräumarbeiten vornehmen. Wenn Sie im Konstruktor Speicher reserviert oder Dateien geöffnet haben, geben Sie diese Ressourcen im Destruktor wieder frei. Eine Klasse kann nur einen Destruktor besitzen. Dieser wird ähnlich einem Konstruktor deklariert, lediglich mit einer vorangestellten Tilde. Den Destruktor sollten Sie in C++ immer virtuell deklarieren. Damit stellen Sie sicher, dass der Compiler auch dann den Destruktor der Klasse aufruft, wenn die Klasse in Programmen eingesetzt wird, die mit Polymorphismus arbeiten. Polymorphismus beschreibe ich in Kapitel 3, dann gehe ich auch noch einmal auf Destruktoren ein. Merken Sie sich hier nur, dass Sie den Destruktor in C++ immer mit virtual deklarieren sollten. Das String-Beispiel bei der Besprechung des Copy-Konstruktors hat bereits einen Destruktor verwendet, der den reservierten Speicherbereich freigibt: // Destruktor virtual ~String() // Freigabe des Speichers if (c_str!= NULL) delete c_str; 1 "!"!%& Objekte können Beziehungen untereinander aufbauen. Dabei wird ein Objekt über eine Eigenschaft eines anderen Objekts referenziert. Eine Person besitzt beispielsweise je eine Eigenschaft Vater und Mutter, die jeweils andere Person-Objekte referenzieren. Assoziationen können einseitig gerichtet sein (eine Person hat eine Mutter und einen Vater) oder auch doppelseitig (eine Person hat einen Vater und eine Mutter, Vater und Mutter referenzieren ihre Kinder). Eine besondere Form der Assoziation ist die Aggregation. Hierbei verhalten sich die Objekte wie ein Ganzes zu seinen Teilen. Ein Auto-Objekt besitzt beispielsweise eine Beziehung zu einem Motor-Objekt, ohne das das Auto nicht funktionieren könnte. Bei der normalen Assoziation sind die Objekte normalerweise gleichberechtigt. Ein Objekt kann auch ohne assoziierte Objekte existieren. Bei einer Aggregation ist das nicht der Fall: Das "Haupt"- Objekt kann ohne seine "Teil"-Objekte nicht (sinnvoll) existieren. Wenn Sie eine Instanz einer anderen Klasse innerhalb einer anderen Klasse statisch erzeugen wollen (das wäre ein Beispiel für eine Aggregation), sind Assoziationen sehr einfach. Das folgende Beispiel deklariert eine Punkt-Klasse, die in einer Kreis-Klasse verwendet wird. Die Punkt-Klasse kapselt den Zugriff auf die Daten, sodass keine ungültigen Punkte eingegeben werden können: Die Basis der OOP: Die Klasse 20

24 class Punkt private: int x; int y; // Methoden zum Setzen der Koordinaten void setx(int x) if (x >= 0) this->x = x; else this->x = 0; // Hier müsste eigentlich eine Ausnahme generiert werden ; void sety(int y) if (y >= 0) this->y = y; else this->y = 0; // Hier müsste eigentlich eine Ausnahme generiert werden // Methoden zum Lesen der Koordinaten int getx() return this->x; int gety() return this->y; Die Basis der OOP: Die Klasse 21

25 Die Kreis-Klasse schließt eine Punkt-Instanz für Ihre Position ein: class Kreis private: int radius; // Objekteigenschaft vom Typ Punkt Punkt Position; ; // Methode zum Setzen des Radius void setradius(int radius) if (radius > 0) this->radius = radius; else this->radius = 0; // Hier müsste eigentlich eine Ausnahme generiert werden // Methode zum Lesen des Radius int getradius() return this->radius; // Methode zur Berechnung des Umfangs double getumfang() return Radius * 2 * ; Der Punkt wird statisch innerhalb der Kreis-Klasse erzeugt und existiert damit automatisch, sobald eine Instanz der Kreis-Klasse erzeugt wird. Die Verwendung ist einfach: Kreis k; k.position.setx(10); k.position.sety(20); k.setradius(100); Statische Unterobjekte werden immer im Speicherbereich des umschließenden Objekts gespeichert. Die Basis der OOP: Die Klasse 22

26 C++ erzeugt die enthaltenen statischen Objekte einer Klasse immer bevor der Konstruktor der Klasse abgearbeitet wird. Sie können die Unterobjekte also im Konstruktor der Klasse initialisieren. Sie können dies einmal über einfache Zuweisungen an die Eigenschaften der Unterobjekte programmieren: // Klasse für einen Kreis class Kreis private: int radius; // Objekteigenschaft vom Typ Punkt Punkt Position; // Konstruktor, dem der Radius und die Position übergeben wird Kreis(int x, int y, int radius) this->position.setx(x); this->position.sety(y); this->radius = radius;... Wenn Sie zur Initialisierung den Konstruktor des Unterobjekts aufrufen wollen, müssen Sie diesen durch einen Doppelpunkt getrennt an den Kopf des Konstruktors der umschließenden Klasse anhängen: class Punkt private: int x; int y; // Konstruktor Punkt(int x, int y) // Aufruf der Methoden zum Setzen, da // diese die übergebenen Werte auf // Gültigkeit überprüfen setx(x); sety(y)... class Kreis private: int radius; // Objekteigenschaft vom Typ Punkt Punkt Position; // Konstruktor, dem die Position und der Radius übergeben wird // Der Konstruktor der Punkt-Klasse wird in der // Initialisierungsliste // des Kreis-Konstruktors aufgerufen, um den Punkt zu // initialisieren Kreis(int x, int y, int radius): Position(x, y) this->radius = radius;... Die Basis der OOP: Die Klasse 23

27 Statische Unterobjekte können nicht vom Typ der umschließenden Klasse sein. Wenn Sie Unterobjekte vom selben Typ wie dem der umschließenden Klasse in eine Klasse einbinden wollen, müssen Sie Zeiger oder Referenzen verwenden. Manchmal muss eine Objekteigenschaft dynamisch, bei oder nach der Erzeugung des Objekts, von außen gesetzt werden. Meist tritt dieser Fall bei normalen Assoziationen ein, bei denen ein Objekt auch ohne seine referenzierten "Partner"-Objekte existieren kann. Bei einem Stammbaum ist dies beispielsweise der Fall: Die Eigenschaft Vater und Mutter einer Person können erst gesetzt werden, wenn die Person erzeugt wird oder wurde. Sie können dazu ganz einfach Zeiger einsetzen: class Person string Vorname; string Nachname; ; // Zeiger für den Vater und die Mutter Person *Vater; Person *Mutter; // Methode zur Rückgabe des vollen Namens string VollerName() return Vorname + " " + Nachname; // Konstruktor Person(string vorname, string nachname, Person *mutter, Person *vater) this->vorname = vorname; this->nachname = nachname; this->mutter = mutter; this->vater = vater; int main(int argc, char* argv[]) // Einige Personen erzeugen und einen kleinen // Stammbaum aufbauen Person p1("anna", "Müller", NULL, NULL); Person p2("hans", "Weber", NULL, NULL); Person p3("gabi", "Müller", &p1, &p2); Person p4("pascal", "Müller", &p1, &p2); Person p5("natalie", "Sparks", NULL, NULL); Person p6("monika", "Müller", &p4, &p5); // Die Großmutter von p6 ermitteln if (p6.mutter!= NULL && p6.mutter->mutter!= NULL) cout << "Die Großmutter von " << p6.vollername() << " ist " << p6.mutter->mutter->vollername() << endl; return 0; Das Beispiel übergibt im Konstruktor der Personenklasse einfach NULL, wenn die Person keinen Vater oder keine Mutter hat. Beim Zugriff müssen Sie natürlich beachten, dass ein Zeiger auch auf NULL zeigen kann. Das Beispiel überprüft vor der Ausgabe des Namens der Großmutter, ob diese überhaupt existiert und nutzt dabei die Tatsache, dass C++ logische Ausdrücke von links nach rechts auswertet und die Auswertung abbricht, wenn ein Teilausdruck false ergibt. Die Basis der OOP: Die Klasse 24

28 Die Idee, statt der Zeiger einfach Referenzen zu verwenden (damit die Referenzierung / Dereferenzierung entfällt), kann in C++ leider nicht umgesetzt werden. Referenzen müssen in C++ immer direkt bei der Deklaration mit einer Instanz des Typs der Referenz initialisiert werden. Schade. Die Basis der OOP: Die Klasse 25

29 2% "'#"+# 2% Die Vererbung ist, neben der Kapselung, ein weiteres, sehr wichtiges Grundkonzept der OOP. Über die Vererbung können Sie neue Klassen erzeugen, die alle Eigenschaften und Methoden von einer Basisklasse, die bei der Erzeugung der neuen Klasse angegeben wird, erben. So können Sie sehr einfach die Funktionalität einer bereits vorhandenen Klasse erben, erweitern und/oder neu definieren. Das Erweitern einer Klasse ist nicht besonders schwierig: Sie implementieren dazu einfach weitere Eigenschaften und Methoden in der neuen Klasse. Neue Methoden können dabei auch geerbte Methoden aufrufen, womit Sie die in der Regel getestete und für gut befundene Funktionalität der Basisklasse auf einfache Weise wiederverwenden können. In diesem Sinne wird die Vererbung häufig für Programme genutzt, bei denen eine Basisfunktionalität in mehreren, unterschiedlichen Klassen vorhanden sein soll. Aber auch das so genannte Überschreiben geerbter Methoden mit einer neuen Programmierung ist möglich. So können Sie neue Klassen erzeugen, die im Prinzip genauso verwendet werden wie die Basisklasse, die aber ihren Job anders erledigen. Diese beiden Grundkonzepte der Vererbung, das Erweitern und Überschreiben, werden häufig gemeinsam genutzt. Die Vererbung wird in der Praxis für eigene Klassen nur relativ selten eingesetzt. Ein Grund dafür ist, dass relativ selten wirklicher Bedarf für Vererbung besteht. Ein anderer Grund ist, dass Programme, die Vererbung sehr intensiv nutzen, meist sehr unübersichtlich und dann auch fehleranfällig werden. Wenn Sie aber echt objektorientierte Programmiersprachen, wie z. B. Java und C# verwenden, kommen Sie ohne die Vererbung nicht aus. Diese Sprachen stellen Ihnen viele Programm- Komponenten in Form von Klassen zur Verfügung, die aber erst erweitert werden müssen, bevor sie sinnvoll verwendet werden können. Wenn Sie z. B. in Java ein Windows-Fenster für Ihre Anwendung benötigen, leiten Sie eine neue Klasse von der Java-Klasse Frame ab. Die Klasse Frame liefert nur ein einfaches Fenster, das noch um die benötigten Fensterelemente (wie Schalter, Textfelder etc.) erweitert werden muss. Ohne Vererbung könnten Sie die Frame-Klasse nicht erweitern und müssten immer mit einfachen Fenstern ohne weitere Elemente arbeiten. * #2%, Die wichtigen Punkte bei der Vererbung sind: die Wiederverwendung von Programmcode, die Wartbarkeit von Programmen und der über die Vererbung erreichte Polymorphismus. Den Polymorphismus beschreibe ich erst in Kapitel 3. Die Wiederverwendung und die Wartbarkeit sind miteinander verwoben. Ich will Ihnen diese Features anhand eines Beispiels erläutern: Bei der Programmierung ist es manchmal notwendig, dass eine gewisse Basisfunktionalität, die in einem Programm (oder Programmteil) verwendet wird, in einem anderen Programm in einer erweiterten Form zur Verfügung stehen muss. Die Basisfunktionalität darf dabei allerdings nicht verändert werden, damit beide Programme zuverlässig laufen. Vererbung und Polymorphismus 26

30 Das folgende Beispiel verdeutlicht diesen wichtigen Punkt: Eine Klasse soll eine serielle Schnittstelle des Computers repräsentieren und die Kommunikation über diese mit irgendwelchen angeschlossenen Geräten vereinfachen. Diese Klasse sollte einige Eigenschaften zur Einstellung der Parameter der seriellen Schnittstelle besitzen. Das wären zum Beispiel Eigenschaften wie ComPort, Baudrate, Parity und Handshake (die Bedeutung dieser Parameter ist an dieser Stelle nicht wichtig). Eine Methode Open öffnet die serielle Schnittstelle mit den angegebenen Parametern, eine Methode Send erledigt das Senden von Zeichenketten. Eine Methode Read liest empfangene Zeichen aus dem Puffer der seriellen Schnittstelle und gibt diese zurück. Ich nenne diese Klasse Comm. Diese Klasse berücksichtigt beim Senden und Empfangen von Daten kein besonderes Protokoll 1, Daten werden einfach Zeichen für Zeichen gesendet und empfangen. Irgendwann ist die Klasse fertig gestellt, getestet und funktioniert (hoffentlich) einwandfrei. // Klasse zur einfachen seriellen Kommunikation class Comm int ComPort; int Baudrate; int Handshake; char Parity; ; bool Open() // für das Beispiel nicht implementiert return true; bool Send(string data) // für das Beispiel nicht implementiert cout << "Sende Daten: " << data << endl; return true; string Read() // für das Beispiel nicht implementiert void Close() // für das Beispiel nicht implementiert // Die Programmierung der Methoden ist nicht Bestandteil // dieses Beispiels In einem Programm, das irgendwann später entwickelt wird, soll eine Kommunikation über die serielle Schnittstelle mit einem externen Gerät programmiert werden, das Daten nach einem DIN- Protokoll sendet und empfängt. Bei einem solchen Protokoll werden die Daten u. a. mit einer Checksumme versehen, die beim Empfang dazu verwendet wird, zu überprüfen, ob die Daten korrekt empfangen wurden. Der Programmierer würde sich jetzt sehr viel Arbeit machen, wenn er das, was in der Comm-Klasse bereits fertig programmiert ist, nicht wiederverwenden würde. Er schreibt also einfach eine neue Klasse, die von der Comm-Klasse abgeleitet wird und die damit alle Eigenschaften und Methoden erbt. Um die neue Funktionalität zu programmieren, muss er lediglich 1 Ein Protokoll beschreibt (im Computer), wie Daten gesendet und empfangen werden. Einfache Protokolle versehen die gesendeten Daten mit einer so genannten Checksumme, die aus den Daten errechnet und an diese hinten angehängt wird. Mit Hilfe dieser Checksumme kann der Empfänger überprüfen, ob die Daten korrekt gesendet wurden. Komplexere Protokolle, wie TCP/IP, trennen die gesendeten Daten zusätzlich noch in kleine Pakete auf, die jedes für sich mit einer Checksumme und einer Paketnummer versehen werden. Vererbung und Polymorphismus 27