C++ Programmierung Teil 6
Klassen II
Teil: (6/?)
Thema: Klassen II
Version: 1.00
Autor: Dr Doo
e-Mail: DrDoo@busch-hacker.de
Datum: 24.04.2000
Da das letzte Tutor schon eine weile her ist fange ich noch mal von vorne an(auf Klassen bezogen).
Klassen:
Ich werde erst mal kurz erläutern, was man unter Klassen versteht. Wenn ihr das Tutorial durchgelesen habt, wird das, so hoffe ich, verstanden sein.
Man stelle sich nun folgende Situation vor:
Wir möchten ein paar Daten(Alter, Größe, Gewicht) über eine Person abfragen, z.B. über den User. Das würden wir wie folgt machen:
1: #include <iostream.h>
2:
3: void main(void)
4: {
5: int alter=0, groesse=0, gewicht=0;
6:
7: cout << "Wie alt sind Sie?";
8: cin >> alter;
9: cout << "\nWie groß sind Sie?";
10: cin >> groesse;
11: cout << "\nWie viel wiegen Sie?";
12: cin >> gewicht;
13:
14: cout << "\n\nAlter: " << alter;
15: cout << "\nGroesse:" << groesse;
16: cout << "\nGewicht" << gewicht;
17:
18: }
Das ist soweit ja auch alles in Ordnung, stellt euch bitte mal vor, wie das Aussieht, wenn man die Daten von hundert Usern und mehr speichern will. Man müßte ja für jeden User, neue Variablen Deklarieren. Und das wäre ziemlich unübersichtlich . oder? Deswegen sollte man Klassen verwenden, um die Übersicht zu behalten. Also das selbe nochmal mit Klassen(Weil ich zu faul bin, belass ich das jetzt bei zwei Personen):
1: #include<iostream.h>
2:
3: class user{ public:
4: int alter;
5: int groesse;
6: int gewicht;
7: };
8:
9: void main(void)
10: {
11: user user_eins;
12: cout << "Wie alt ist User 1?";
13: cin >> user_eins.alter;
14: cout << "\nWie gross ist User 1?";
15: cin >> user_eins.groesse;
16: cout << "\nWie viel wiegt User 1?";
17: cin >> user_eins.gewicht;
18:
19: user user_zwei;
20: cout << "\n\n\nWie alt ist User 2?";
21: cin >> user_zwei.alter;
22: cout << "\nWie gross ist User 2?";
23: cin >> user_zwei.groesse;
24: cout << "\nWie viel wiegt User 2?";
25: cin >> user_zwei.gewicht;
26:
27: cout << "Alter von User 1: " << user_eins.alter;
28: cout << "\nGroesse von User 1: " << user_eins.groesse;
29: cout << "\nGewicht von User 1 " << user_eins.gewicht;
30: cout << "\n\n\nAlter von User 2 :" << user_zwei.alter;
31: cout << "\nGroesse von User 2: " << user_zwei.groesse;
32: cout << "\nGewicht von User 2: " << user_zwei.gewicht;
33:
34: }
Erläuterung:
Um eine Klasse benutzen zu können, muß sie zuerst deklarieren werden. Das geschieht in Zeile 3. Wir definieren eine Klasse, die wir "user" nennen. Man deklariert Klassen mit dem Schlüsselwort "class"(=klasse). Danach folgt die öffnende geschweifte Klammer. Innerhalb der Klammern, kann man, wie in einer Funktion Variablen, Funktionen etc. deklarieren. Wenn man aber Variablen Deklariert, so muß beachtet werden, dass man ihnen, nicht wie sonst, nicht direkt einen Wert zuordnen kann! Wir erzeugen drei Variablen vom Typ integer.
Nun beenden wir die Definition der Klasse mit der schließenden geschweiften Klammer und einem Semikolon. In Zeile neun beginnt die Main-Funktion.
In Zeile elf wird es interessant: Hier erzeugen wir eine Instanz der Klasse "user".
Wir erzeugen ein Objekt von der Klasse "user". Diese Instanz hat die selben "Eigenschaften", wie die eigentliche Deklaration. Sie besitzt also auch die darin deklarierten Variablen(alter, groesse, gewicht). Man kann das als eine "Kopie" der Klasse verstehen, da sie die selben Eigenschaften besitzt(die Instanz "unser_eins"). Wir müssen eine Instanz der Klasse "user" erstellen, da es sonst nicht funktioniert. Man kann so viele Instanzen eines Typs erzeugen wie man will. Und jede Instanz ist "eigenständig". Das heißt, wenn ich den Wert der Variable . gewicht. in der Instanz . unser_eins. ändere, so bleibt der Wert der Variablen . gewicht. in der Instanz . user_zwei. unberührt.
Die Deklaration der Klasse kann man sich also wie ein Muster vorstellen, dass man nicht anrühren darf. Von diesem Muster erstellt man so viele Kopien, wie man braucht, die man dann auch verändern kann.
Man kann dies mit einem Muster für ein Bewerbungsschreiben vergleichen, dass man mit hilfe von "Word" erstellt hat. Dieses Muster benutzt man immer wieder, um sich bei unterschiedlichen Firmen zu bewerben. Man wird das Muster aber nicht einfach überschreiben, sondern schön braf eine Kopie davon erstellen, damit man es später auch noch einmal verwenden kann. Ich hoffe, dass euch jetzt einigermaßen klar geworden ist, was eine Instanz ist.
In den Zeilen 11-17 werden die Informationen vom Benutzer abgefragt. Die Werte werden in den Variablen der Instanz "user_eins" gespeichert. Dies macht man, in dem man erst die Instanz und dann die Variable in der Instanz angibt, getrennt durch einen Punkt. Die Ausgabe geschieht genauso. Das ist nicht weiter kompliziert.
Private und Public:
Euch ist sicher das "public" in Zeile drei aufgefallen. Im folgendem Abschnitt will ich erklären, was es damit auf sich hat:
Es gibt zwei arten von Elementen: private und public. Auf öffentliche(public) Elemente kann man direkt zugreifen auf private Elemente hingegen kann man nur mit Hilfe von Elementen aus der selben Klasse zugreifen. Dazu ein Beispiel:
1: #include<iostream.h>
2:
3: class user{
4: public:
5: int alter;
6: int groesse;
7: void zuweisenGewicht(int userEins);
8: int ausgebenGewicht();
9: private:
10: int gewicht; };
11:
12: void user::zuweisenGewicht(int userEins){
13: gewicht = userEins; }
14:
15: int user::ausgebenGewicht(){
16: return gewicht; }
17:
18: int main()
19: {
20: int gew=0;
21: user user_eins;
22:
23: cout << "Wie alt ist User Eins?";
24: cin >> user_eins.alter;
25: cout << "\nWie gross ist User Eins?";
26: cin >> user_eins.groesse;
27: cout << "\nWie viel wiegt User Eins?";
28: cin >> gew;
29: user_eins.zuweisenGewicht(gew);
30:
31: cout << "\n\n\nAlter: " << user_eins.alter;
32: cout << "\nGroesse: " << user_eins.groesse;
33: cout << "\nGewicht: " << user_eins.ausgebenGewicht();
34: }
Erläuterung:
In den Zeilen 3-10 Deklarieren wir die Klasse "user". Diese ist in einen . public. und in einen . private. Teil unterteilt. Auf die Elemente im . public. Teil, können wir direkt zugreifen(siehe Zeilen 31,32). Wenn wir aber auf die private Variable "gewicht" zugreifen wollen, so müssen wir das über Umwege tun. Dies machen wir, indem wir zwei öffentliche Funktionen Deklarieren, auf die wir ja direkt zugreifen können. Eine Funktion(zuweisenGewicht() ) benutzen wir, um der privaten Variablen . gewicht. einen Wert zuweisen zu können. Dies ist möglich, da man auf private Elemente mit anderen Elementen aus der selben Klasse zugreifen kann. Die zweite Funktion(ausgebenGewicht() ) benutzen wir dazu, den Wert der privaten Variable . gewicht. auf dem Bildschirm auszugeben.
Nun machen wir einen Sprung zu Zeile 18, damit wir den Programmverlauf auch in der Reihenfolge besprechen können, wie der Code ausgeführt wird:
In Zeile 20 erzeugen wir eine Variable namens . gew. . In Zeile 21 erzeugen wir eine Instanz der Klasse user(user_eins). Nun wir der Benutzer nach den Informationen Abgefragt(Zeilen 23-28). In Zeile 29 wird die Funktion . zuweisenGewicht(). aufgerufen, die ja als . public. deklariert ist. Also können wir auf diese zugreifen. Wir übergeben den Wert der Variablen . gew. an die Funktion(bzw an . int userEins. (Zeile 12). In der Funktion wird der Wert der Variablen . userEins. (die ja den selber Wert wie . gew. hat) der privaten Variablen . gewicht. zugewiesen, was ja möglich ist, weil wir innerhalb der Klasse auf diese zugreifen.
In den Zeilen 31-33 werden die Werte wieder auf den Bildschirm ausgegeben. Um das Gewicht auszugeben, müssen wir aber wieder einen Umweg nehmen:
Wir rufen die Elementfunktion . ausgebenGewicht(). auf(Zeile 33), welche dann den Wert von der Privaten Variable . gewicht. zurückgibt.
Wenn man Elementfunktionen Definieren will(Zeilen 12-16), so tut man dies, indem man erst den Namen der Klasse dann zwei Doppelpunkte und anschließend den Namen der Funktion schreibt. Dann folgt die Definition der Funktion.
So! Das ist genug zum Thema Klassen. Das mag vielleicht auf den ersten Blick ziemlich kompliziert und unlogisch erscheinen, aber wenn man das einmal verstanden hat, dann ist das gar nicht mehr so schwer. Falls ihr noch fragen habt, dann schreibt diese an die bekannte e-Mailaddresse!
Dr. Doo
Greetings to all Busch-Hackers!!!