Du bist hier: Startseite > Entwicklung (C/C++) > C++ Grundlagen > Klassen Abstraktion und virtuelle Methoden

Klassen Abstraktion und virtuelle Methoden

Eine abstrakte Klasse in C++ ist eine Klasse, die mindestens eine abstrakte Methode enthält.
Eine abstrakte Methode in C++ ist virtuell und dadurch gekennzeichnet, dass ihre Deklaration durch "= 0;" abgeschlossen wird.
Von abstrakten Klassen können keine Objekte erzeugt werden, sie muss abgeleitet werden.

Es können wie im Beispiel ( std::string getText(){...} ) auch Methoden vordefiniert und deklariert werden, die in der abgeleiteten Klasse nicht neu definiert werden müssen (Vererbung).

virtual void ueberschreiben(){...} in der abstakten Klasse zeigt, wie Methoden deklariert und definiert werden können. Es steht dem Programmierer frei, ob er diese Methode später überschreibt oder nicht.

Eine weitere Eigenheit von C++ sind Destruktoren, die für abschließende Aufgaben wie Speicherfreigabe verwendet werden. Jede Klasse, deren Attribute nicht primitive Typen sind oder die andere Ressourcen verwendet (wie z. B. eine Datenbankverbindung), sollte diese unbedingt in ihrem Destruktor freigeben. Um immer auf den richtigen Destruktor zugreifen zu können, muss der Destruktor in der abstrakten Klasse als virtual deklariert sein.

Datei:  Quelldateien/main.cpp
  1. #include <iostream> // std::cout, std::endl, std::cin
  2. #include <stdlib.h> // EXIT_SUCCESS
  3. #include <string> // std::string
  4.  
  5. class abstrakteKlasse
  6. {
  7. public:
  8. virtual void ueberschreiben()
  9. {
  10. std::cout << "Diese Methode kann ueberschrieben werden!" << std::endl;
  11. }
  12. protected:
  13. std::string text;
  14. std::string getText()
  15. {
  16. return this->text;
  17. }
  18. // virtual und =0; sorgt dafür das in der abgeleiteten Klasse start() deklariert werden muss
  19. virtual void start() = 0;
  20. virtual ~abstrakteKlasse() {}; // Destruktor für jede abgeleitete Klasse erzwingen
  21. };
  22.  
  23. class Klasse : public abstrakteKlasse
  24. {
  25. public:
  26. void start() // Implementierung der virtuellen Methode
  27. {
  28. this->text = "Klasse gestartet";
  29. std::cout << this->getText() << std::endl;
  30. }
  31. /*
  32. virtual void ueberschreiben()
  33. {
  34. std::cout << "Diese Methode wurde ueberschrieben!" << std::endl;
  35. }
  36. */
  37. ~Klasse() // Implementierung des virtuellen Destruktor
  38. {
  39. std::cout << "Klasse zerstoert" << std::endl;
  40. }
  41. };
  42.  
  43. int main(void)
  44. {
  45. Klasse *pKlasse = (new Klasse);
  46. pKlasse->start();
  47. pKlasse->ueberschreiben();
  48. delete pKlasse;
  49.  
  50. std::cin.get();
  51. return EXIT_SUCCESS;
  52. }
Im Beispiel wurde darauf verzichtet beide Klassen auszulagern, um die Verständlichkeit zu erhöhen!

Kommentare zu diesem Beitrag

Sie müssen angemeldet sein, um eine Nachricht zu erstellen. Anmelden »