C++-Programmierung/ Eigene Datentypen definieren/ Das Klassenkonzept

Aus Wikibooks
Zur Navigation springen Zur Suche springen


In einem späteren Abschnitt werden Sie etwas über objektorientierte Programmierung erfahren. Die notwendige Basis dafür werden wir in diesem Abschnitt erarbeiten. Sie haben inzwischen einiges über die verschiedenen Basisdatentypen gelernt und auch erfahren, wie Sie diese Daten mithilfe von Funktionen manipulieren können. Im Prinzip könnten Sie mit diesen Mitteln bereits jedes beliebige Programm schreiben. Allerdings werden Programme, die mit diesen Mitteln geschrieben wurden oft unübersichtlich, sobald eine gewisse Größe überschritten wird. Aus diesem Grund wurde ein neues Konzept erdacht, das für mehr Übersicht sorgt. Anstatt einfach Daten (Variablen) zu haben, die von Funktionen manipuliert werden, fasst man logisch zusammengehörende Daten und die darauf arbeitenden Funktionen zu einem neuen Konstrukt zusammen. Dieses Konstrukt nennt sich „Klasse“ und das Zusammenfassen wird als Kapselung bezeichnet.

Eine Klasse hat üblicherweise einen Namen und besteht aus Variablen und Funktionen, welche als Klassenmember (zu deutsch etwa Mitglieder) bezeichnet werden. Ein Funktionsmember bezeichnet man auch als Methode der Klasse. Ein wesentliche Vorteil der Kapselung besteht darin, dass ein Nutzer der Klasse nicht wissen muss, wie die Klasse intern arbeitet. Andererseits können Sie die konkrete Implementierung der Klasse jederzeit ändern, ohne dass der Code, in dem die Klasse verwendet wird, geändert werden muss. Lediglich bei Schnittstellenänderungen muss auch Code außerhalb der Klasse angepasst werden. Als Schnittstelle bezeichnet man die Member der Klasse, die von außen sichtbar sind. Dies werden meistens eine Reihe von Methoden sein, während Variablen nur sehr selten direkt sichtbar sein sollten.

Eine Klasse ist ein benutzerdefinierter Datentyp. Somit können Sie also, genau wie bei einem Basisdatentyp, Variablen vom Typ der Klasse (= deren Name) erstellen. Eine Variable vom Typ einer Klasse beinhaltet alle in der Klasse deklarierten Variablen. Somit verbraucht eine Klassenvariable so viel Speicherplatz, wie die Variablen, die in ihr deklariert wurden. Natürlich hat der Übersetzer hier einige Freiräume, sodass Sie nicht einfach davon ausgehen können, dass eine Klassenvariable genau so viel Speicherplatz belegt, wie die Summe ihrer Variablenmember. Wenn der Übersetzer es aus Optimierungsgründen für sinnvoll hält, etwas mehr Speicherplatz zu nutzen, um etwa die internen Variablen so im Speicher auszurichten, dass auf sie schnell zugegriffen werden kann, darf er dies tun. Wenn Sie die genaue Größe wissen möchten, die eine Variable einer Klasse im Speicher belegt, können Sie den sizeof-Operator auf die Klasse oder eine Variable vom Typ der Klasse anwenden.

Der Inhalt einer solchen Variable ist ein „Objekt“ der Klasse. Ebenso wie es vom Typ 'int' viele Variablen mit unterschiedlichen Werten in einem Programm geben kann, so kann es viele Objekte mit unterschiedlichen Werten vom selben Klassen-Typ in einem Programm geben.

Eine Klasse ist wie ein Bauplan für Objekte. Klassen haben zwei spezielle Methoden, die beim Erstellen bzw. Zerstören eines Objektes vom Typ der Klasse aufgerufen werden. Erstere bezeichnet man als Konstruktor und die zweite als Destruktor der Klasse.

Ähnlich wie Funktionen ihre lokalen Variablen haben können, auf die „von außen“ nicht zugegriffen werden kann, kann es innerhalb einer Klasse verschiedene Sichtbarkeitsbereiche geben, die darüber entscheiden, ob eine Membervariable nur innerhalb von Methoden der Klasse oder auch von außerhalb verwendet werden kann. Diese Sichtbarkeitsbereiche entscheiden entsprechend darüber, welche Membervariablen zur Schnittstelle gehören.

Es gibt einige allgemeine Operatoren für Klassen und Objekte. Es ist möglich, einige dieser Operatoren für eine Klasse zu überladen, sodass diese dann auf Klassenobjekte angewendet werden können.

Das waren jetzt wieder sehr viele Informationen auf wenig Raum, aber machen Sie sich keine Sorgen, wenn Sie sich nicht alles merken konnten: In den nächsten Kapiteln wird auf die verschiedenen Eigenschaften von Klassen noch näher eingegangen, sodass Sie die Gedanken dahinter nachvollziehen können.

Ein eigener Datentyp[Bearbeiten]

Nun wird es aber Zeit, dass wir auch mal eine eigene Klasse schreiben. Das folgende Beispiel soll die prinzipielle Arbeitsweise einer Klasse demonstrieren.

Nuvola-inspired-terminal.svg
 1 #include <iostream>
 2 
 3 class Auto{
 4 public:
 5     Auto(int tankgroesse, float tankinhalt, float verbrauch);
 6 
 7     void info()const;
 8 
 9     void fahren(int km);
10     void tanken(float liter);
11 
12 private:
13     int   tankgroesse_;
14     float tankinhalt_;
15     float verbrauch_;
16 };
17 
18 Auto::Auto(int tankgroesse, float tankinhalt, float verbrauch):
19     tankgroesse_(tankgroesse),
20     tankinhalt_(tankinhalt),
21     verbrauch_(verbrauch)
22     {}
23 
24 void Auto::info()const{
25     std::cout << "In den Tank passen " << tankgroesse_ << " Liter Treibstoff.\n";
26     std::cout << "Aktuell sind noch " << tankinhalt_ << " Liter im Tank.\n";
27     std::cout << "Der Wagen verbraucht " << verbrauch_ << " Liter pro 100 km.\n";
28     std::cout << std::endl;
29 }
30 
31 void Auto::fahren(int km){
32     std::cout << "Fahre " << km << " km.\n";
33     tankinhalt_ -= verbrauch_*km/100;
34 
35     if(tankinhalt_ < 0.0f){
36         tankinhalt_ = 0.0f;
37 
38         std::cout << "Mit dem aktuellen Tankinhalt schaffen Sie die Fahrt leider nicht.\n";
39         std::cout << "Der Wagen ist unterwegs liegengeblieben, Zeit zu tanken!\n";
40     }
41 
42     std::cout << std::endl;
43 }
44 
45 void Auto::tanken( float liter ) {
46     std::cout << "Tanke " << liter << " Liter.\n";
47     tankinhalt_ += liter;
48 
49     if( tankinhalt_ > tankgroesse_ ) {
50         tankinhalt_ = tankgroesse_;
51 
52         std::cout << "Nicht so übereifrig! Ihr Tank ist jetzt wieder voll.\n";
53         std::cout << "Sie haben aber einiges daneben gegossen!\n";
54     }
55 
56     std::cout << std::endl;
57 }

Diese Klasse nutzt vieles, was Sie im Laufe dieses Abschnittes noch kennenlernen werden. Für den Moment sollten Sie wissen, dass diese Klasse drei verschiedene Daten beinhaltet. Diese Daten sind die drei Variablen, deren Namen auf einen Unterstrich (_) enden. Vier Funktionen arbeiten auf diesen Daten.

Sie haben nun gesehen, wie die Klasse aufgebaut ist, und in den folgenden Kapiteln wird dieser Aufbau genauer erläutert. Jetzt sollen Sie jedoch erst einmal den Vorteil einer Klasse verstehen, denn um eine Klasse zu benutzen, müssen Sie keine Ahnung haben, wie diese Klasse intern funktioniert.

Nuvola-inspired-terminal.svg


 1 int main(){
 2     Auto wagen(80, 60.0f, 5.7f);
 3 
 4     wagen.info();
 5 
 6     wagen.tanken(12.4f);
 7     wagen.info();
 8 
 9     wagen.fahren(230);
10     wagen.info();
11 
12     wagen.fahren(12200);
13     wagen.info();
14 
15     wagen.tanken(99.0f);
16     wagen.info();
17 }
Crystal Clear app kscreensaver.svg
Ausgabe:
 1 In den Tank passen 80 Liter Treibstoff.
 2 Aktuell sind noch 60 Liter im Tank.
 3 Der Wagen verbraucht 5.7 Liter pro 100 km.
 4 
 5 Tanke 12.4 Liter.
 6 
 7 In den Tank passen 80 Liter Treibstoff.
 8 Aktuell sind noch 72.4 Liter im Tank.
 9 Der Wagen verbraucht 5.7 Liter pro 100 km.
10 
11 Fahre 230 km.
12 
13 In den Tank passen 80 Liter Treibstoff.
14 Aktuell sind noch 59.29 Liter im Tank.
15 Der Wagen verbraucht 5.7 Liter pro 100 km.
16 
17 Fahre 12200 km.
18 Mit dem aktuellen Tankinhalt schaffen Sie die Fahrt leider nicht.
19 Der Wagen ist unterwegs liegengeblieben, Zeit zu tanken!
20 
21 In den Tank passen 80 Liter Treibstoff.
22 Aktuell sind noch 0 Liter im Tank.
23 Der Wagen verbraucht 5.7 Liter pro 100 km.
24 
25 Tanke 99 Liter.
26 Nicht so übereifrig! Ihr Tank ist jetzt wieder voll.
27 Sie haben aber einiges daneben gegossen!
28 
29 In den Tank passen 80 Liter Treibstoff.
30 Aktuell sind noch 80 Liter im Tank.
31 Der Wagen verbraucht 5.7 Liter pro 100 km.

In der ersten Zeile von main() wird ein Auto-Objekt mit dem Namen wagen erstellt. Anschließend werden Methoden dieses Objekts aufgerufen, um die Daten darin zu verwalten. Von den Daten innerhalb des Objekts kriegen Sie beim Arbeiten mit dem Objekt überhaupt nichts mit. Lediglich die Ausgabe verrät, dass die drei Methoden untereinander über diese Daten „kommunizieren“.

Die vierte Methode (jene, die mit dem Klassennamen identisch ist) wird übrigens auch aufgerufen. Gleich in der ersten Zeile von main() wird diese Methode genutzt, um das Objekt zu erstellen. Es handelt sich also um den Konstruktor der Klasse.