Verfügbare Informationen zu "C++ Teil6"
Qualität des Beitrags: Beteiligte Poster: biohazard Forum: www.biohazard-die-nr1.de.vu aus dem Unterforum: Tutorials Antworten: 1 Forum gestartet am: Mittwoch 14.04.2004 Sprache: deutsch Link zum Originaltopic: C++ Teil6 Letzte Antwort: vor 20 Jahren, 10 Tagen, 13 Stunden, 24 Minuten
Alle Beiträge und Antworten zu "C++ Teil6"
Re: C++ Teil6
biohazard - 15.04.2004, 14:56C++ Teil6
C++ Programmierung - Teil
6
Klassen II
Teil: (6/?)
Thema: Klassen II
Version: 1.00
e-Mail: Webmaster@Hackernetz.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üsste 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 noch mal 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, muss 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 muss 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 brav 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.
Mit folgendem Code, können Sie den Beitrag ganz bequem auf ihrer Homepage verlinken
Weitere Beiträge aus dem Forum www.biohazard-die-nr1.de.vu
Ähnliche Beiträge wie "C++ Teil6"
[SAMMLUNG] vincentvega (story teil6) - vincentvega (Mittwoch 06.09.2006)