[Home]
für Einsteiger!
C++ Einführung
C++ Variablen im Speicher, Zeiger
C++ Texte etc.
C++ Dateien, Formatierte Ausgabe, ...
C++ OOP
Hilfe / Anhang
Downloads / Links
Partner
 
Fehler melden / Kontakt
Impressum
 
Powered by GeSHi
Valid HTML 4.01 Transitional
Seite:  [1] 2 3 - Drucken

Inhalt:


Daten Strukturen: struct

Stell dir vor, du hast ein Register mit allen Autos der Straße:
  • Typ
  • Besitzer
  • PS
  • max. Geschwindigkeit
  • Türen
  • Klimaanlage

Bevor du jetzt anfängst, für jedes Auto eine neue Variable "Typ" anzulegen, solltest du dir Gedanken machen, ob dir keine bessere Lösung einfällt! Wie wäre es denn zum Beispiel mit dem Datentyp "automobil"?
Quelltext
  1. struct automobil
  2. {
  3.  std::string typ;
  4.  std::string besitzer;
  5.  int ps;
  6.  int max_v;
  7.  int tueren;
  8.  bool klima; 
  9. }meins,test,test2; //Anlegen von Autos (Möglichkeit 1)
  10.  

 

Halt! Was soll das?

BeispielWir steigen soeben in die OOP (Objektorientierte Programmierung) ein! "meins" ist zum Beispiel ein Objekt/eine Instanz der Klasse "automobil". Die OOP dient dazu, eigene Datentypen zu definieren und zu organisieren.
 
Die OOP hilft, Muster zu erzeugen. Der Mensch selbst typisiert Dinge immer, etwa wenn du durch die Stadt gehst und einen Porsche 911 siehst: Du siehst gleichzeitig einen Porsche, ein Auto, ein Vehikel, ein "Ding", das in der Welt existiert. Sag jemand nun "Vehikel". muss das allerdings nicht zwingend ein Porsche 911 sein, es kann alles mögliche sein. Nur die oben genannte Kette stellt einen Porsche 911 dar.
In C++ geht das genauso: Wir können ein abstraktes Bild der Wirklichkeit schaffen - eben durch die OOP.

 
Dabei haben Klassen (etwa Ding, Vehikel, Porsche, Porsche 911) "Eigenschaften", also eine Art lokale Variable, auch Membervariable genannt. Im obigen Beispiel wäre das zum Beispiel "klima" oder "tueren"!
 
Außerdem können Klassen auch Methoden haben, also interne Funktionen. Wir haben auch diese schon kennengelernt, etwa als wir uns mit Dateien beschäftigt haben:
 
Denn auch bei "std::fstream" handelt es sich um eine Klasse, die Methoden besitzt. Zum Beispiel "open()".

Auf die Werte einer Klasse zugreifen

Um auf die Werte einer Klasse zugreifen zu können, muss man zuerst einmal verstehen, was eine Klasse überhaupt ist!
Eine Klasse ist nur eine Vorlage, nach der dann Objekte erstellt werden. Genauso wie du nicht schreiben kannst: "int=0", musst du auch zuerst ein Objekt anlegen, und kannst nicht der Klasse Werte zuweisen! (also: "int i=0;")

 
Also legen wir noch einmal ein - nein gleich vier - Objekte vom Typ Automobil an:
Quelltext[734B]Download
  1. #include <iostream>
  2. #include <string>
  3.  
  4. struct automobil
  5. {
  6.   std::string typ;
  7.   std::string besitzer;
  8.   int ps;
  9.   int max_v;
  10.   int tueren;
  11.   bool klima; 
  12. }testobjekt_1,testobjekt_3;     //Anlegen von Autos (Möglichkeit 1)
  13.  
  14. int main()
  15. {
  16.   automobil testobjekt_2,testobjekt_4;
  17.   //^Anlegen von Autos (Möglichkeit 2)
  18.  
  19.   testobjekt_1.typ="LEPORELLO"; //LEPORELLO/LEPO->Wikipedia ;)
  20.   testobjekt_2.typ="Raserati";  //Punktoperator
  21.   testobjekt_3.typ="Ferfari";
  22.   testobjekt_4.typ="Popel";
  23.  
  24.   testobjekt_1.ps=200;
  25.   testobjekt_2.ps=500;
  26.   testobjekt_3.ps=100;
  27.   testobjekt_4.ps=2;
  28.  
  29.   std::cout << testobjekt_1.ps << " : " << testobjekt_2.ps << " : "
  30.             << testobjekt_3.ps << " : " << testobjekt_4.ps << std::endl;
  31.  
  32.   return 0;
  33. }
  34.  
  35.  

 

Methoden - Die Memberfunktionen der Klassen

Methoden sind wie folgt aufgebaut:
  • Ein Prototyp in der Klasse
  • "<Rückgabetyp> <struct-name/Klassenname>::<Methodenname>(<...>)"

Natürlich kannst du auch auf den Prototypen verzichten, und den Methodeninhalt direkt in die Klassendeklaration schreiben, was meiner Meinung nach allerdings unübersichtlicher ist... (Beispiele folgen)
 

Was ist "this"?

Wenn du in einer Methode Eigenschaften des Objektes verwenden willst, benutzt du "this->" (s.u.). Dabei handelt es sich um einen Pointer auf das aktuelle Objekt! Mittels des Pfeils kannst du, wie auch mit dem Punktoperator Eigenschaften und Methoden eines Objektes ansprechen, allerdings über einen Pointer. Dabei sind die folgenden Zeilen gleichbedeutend:
Quelltext
  1. this->test
  2. (*this).test
  3.  

Würdest du die Klammern vergessen, würde die "*(this.test)" gemeint...

getter und setter-Methoden (mit this)

Bei diesen Methoden handelt es sich um Methoden, die Eigenschaften auslesen und zurückgeben, bzw. solche, die Werte setzen. Dies kann nützlich sein, wenn man z.B. die Lesitung eines Autos intern in PS speichert, aber entweder mit kW (Kilowatt) oder mit PS arbeiten möchte: (1 kW=1.36 PS, 1 PS=0.736 kW)
 
Da getter keine Werte ändern, kann es sehr nützlich sein, sie als "const" zu definieren. So kannst du vermeiden, das ein Programmierfehler doch Werte ändert... (z.B.: "if (wert=1)"). Wie dies geschieht, kannst du unten und im Beipiel auf der übernächsten Seite sehen!
Quelltext[922B]Download
  1. //+++++++++++++++++++++++++++++++++++++++++++++++
  2. // ps_kw.cpp
  3. //demonstriert getter und setter
  4. //+++++++++++++++++++++++++++++++++++++++++++++++
  5. #include <iostream>
  6.  
  7. struct automobil
  8. {
  9.   int ps;
  10.  
  11.   int  get_ps() const;
  12.   void set_ps(int ps);
  13.   int  get_kw() const;
  14.   void set_kw(int kw);
  15. };                      //Nix anlegen
  16.  
  17. //+++++++++++++++++++++++++++++++++++++++++++++++
  18. // main()
  19. //+++++++++++++++++++++++++++++++++++++++++++++++
  20. int main()
  21. {
  22.   automobil test;
  23.  
  24.   test.set_ps(200);
  25.   std::cout << test.get_kw() << std::endl;
  26.  
  27.   return 0;
  28. }
  29.  
  30. //+++++++++++++++++++++++++++++++++++++++++++++++
  31. // automobil - Implementieren von Klassenmethoden
  32. //+++++++++++++++++++++++++++++++++++++++++++++++
  33. int  automobil::get_ps() const
  34. {
  35.   return ps;
  36. }
  37.  
  38. void automobil::set_ps(int ps)
  39. {
  40.   this->ps=ps;
  41. }
  42.  
  43. int  automobil::get_kw() const
  44. {
  45.   return (1.36 * this->ps);
  46. }
  47.  
  48. void automobil::set_kw(int kw)
  49. {
  50.   this->ps=0.736 * kw;
  51. }
  52.  
  53.  

 

public oder private (öffentlich oder privat)?

Alle Methoden und Eigenschaften, die wir bisher besprochen haben, waren öffentlich ("public"), aber es gibt auch die Möglichkeit, sie als "private" zu deklarieren. Danach können nur noch die Methoden dieser Klasse auf diese Elemente zugreifen, von außen sind sie nicht zu sehen:
Quelltext
  1. //+++++++++++++++++++++++++++++++++++++++++++++++
  2. // ps_kw.cpp
  3. //demonstriert getter und setter
  4. //+++++++++++++++++++++++++++++++++++++++++++++++
  5. #include <iostream>
  6.  
  7. struct automobil
  8. {
  9.  private:
  10.   int ps;
  11.  
  12.  public:
  13.   int  get_ps();
  14.   void set_ps(int ps);
  15.   int  get_kw();
  16.   void set_kw(int kw);
  17. };                      //Nix anlegen
  18.  
  19. //+++++++++++++++++++++++++++++++++++++++++++++++
  20. // main()
  21. //+++++++++++++++++++++++++++++++++++++++++++++++
  22. int main()
  23. {
  24.   automobil test;
  25.  
  26.   test.set_ps(200);
  27.   std::cout << test.get_kw() << std::endl;
  28.  
  29.   return 0;
  30. }
  31.  
  32. //+++++++++++++++++++++++++++++++++++++++++++++++
  33. // automobil - Implementieren der Klassenmethoden
  34. //+++++++++++++++++++++++++++++++++++++++++++++++
  35.  
  36. //...
  37.  

 
So kannst du Fehlerquellen einschränken! Eine dritte Möglichkeit dieser "Rechte" werden wir später behandeln!

Wie geht's weiter?

Auf der nächsten Seite geht es um Konstruktoren und Destruktoren!
Seite:  [1] 2 3 - Drucken