Destruktoren in C++ (leicht erklärt)

Einleitung

Es ist kurz vor Weihnachten und wie jeder weiß, erstellen Elfen das Spielzeug für all die Kinder, die der Weihnachtsmann beschenkt. Da jedoch das Jahr 2020 ist und die meisten Kinder sich Videospiele wünschen, werden viele Elfen nun C++ lernen müssen.

Damit die Elfen nicht verzweifeln, möchte ich heute die Destruktoren in C++ so einfach wie möglich erklären.

Was sind Destruktoren?

Eine Klasse in C++ besteht immer zumindest aus einem Konstruktor und Destruktor. Wie du dir aus dem Namen wohl herleiten kannst, hat der Konstruktor die Aufgabe etwas zu erstellen und der Destruktor hat die Aufgabe ein Objekt zu ZERSTÖREN.

Konstruktor und Destruktor sind sogenannte “Member” einer Klasse. Also Funktionen innerhalb einer Klasse. Member deswegen, weil sie zu der Klasse dazugehören(Member übersetzt heißt Mitglied).

Wie sieht ein Destruktor aus?

Ein Destruktor hat ähnlich wie der Konstruktor den gleichen Namen wie die Klasse, mit einer dem Namen davorgestellten Tilde(~). Wenn also die Klasse “Auto” heißt, dann heißt die Destruktor-Methode: ~Auto()

Kurze Erinnerung: Eine Methode ist eine Funktion innerhalb einer Klasse.

Die Namenskonvention ist notwendig, damit der Compiler versteht, welcher Member den Destruktor bzw. Konstruktor darstellt. Denn wir rufen beide in der Regel nicht explizit auf.

Ok, aber wofür ist ein Destruktor nun zuständig?

Der Destruktor hat die Aufgabe Speicherplatz freizugeben. Falls du mit C vertraut bist, übernimmt er die Aufgabe von free().

Außerdem ist der Destruktor nicht nur für das Zerstören des Objekts zuständig, sondern auch, um zu bestimmen was passieren soll, wenn das Objekt zerstört wird.

Wann wird der Destruktor aufgerufen?

Er wird immer dann automatisch aufgerufen wenn ein Block verlassen wird, indem das Objekt definiert wurde. Vorausgesetzt, das Objekt ist nicht statisch deklariert worden. Das erspart dem Entwickler eine Menge Arbeit, da er nicht jedes mal mit free() Speicher freigeben musst. Bei globalen und statischen Objekten hingegen wird das Objekt dann zerstört, wenn die main() Funktion verlassen wird.

Das heißt du musst den Destruktor nicht selbst aufrufen, der Compiler tut dir den Gefallen(danke Compiler). Es ist jedoch im Gegensatz zum Konstruktor möglich einen Destruktor auch explizit(komplizierter Fachbegriff für ausführlich) aufzurufen indem man Namen verwendet.

Was wenn ich keine Lust habe einen Destruktor zu definieren?

Dann stellt der Compiler einen Standard-Destruktor bereit(Default-Destruktor)

Welchen Rückgabetyp hat ein Destruktor?

Ähnlich wie der Konstruktor, hat auch der Destruktor keinen Rückgabetyp, also auch nicht den Rückgabetyp void.
Im Gegensatz zum Konstruktor jedoch, hat der Destruktor auch keine Parameter. Was somit auch bedeutet das wir ihn nicht überladen können.

Überladen von Funktionen:
Bedeutet, dass man Funktionen mit dem gleichen Namen mehrmals definieren kann, was in C++ möglich ist, vorausgesetzt, dass sich die Anzahl der Parameter in den verschiedenen Funktionen unterscheidet.(mehr über Funktionsüberladung erfahren)

Das bedeutet außerdem das es somit auch nur einen Destruktor geben kann!

Beispiel

#include <iostream>
using namespace std;

/*Wir haben eine Klasse namens Auto mit einem Attribut zum Speichern der Anzahl der Türen
Innerhalb dieser Klasse deklarieren wir den Konstruktor und Destruktor
*/
class Auto{
  private:
    int tueren;
  public:
    Auto(int t); // Konstruktor
    ~Auto(); // Destruktor
};
/*
Theoretisch hätte ich die Funktionsdefinition direkt in der Klasse machen können. Jedoch ist es üblich die Deklaration in der Klasse
und die Definition der Member aufzuteilen, indem man eine .cpp-Datei für die Definition erstellt und eine .h-Datei für die Klasse
Da das aber schnell unübersichtlich wird und den Lernprozess erschwert habe ich das hier in einer Datei gemacht.
*/



//So sieht ein Konstruktor aus:
Auto::Auto(int t){
// hier wird das Objekt initialisiert, indem die Attribute mit Inhalten belegt werden.
  tueren = t;
}
/*Der doppelte Doppelpunkt heißt Gültigkeitsoperator und
ist notwendig, um den Member zu Definieren. Mit seiner Hilfe
weiß der Compiler auf welche Klasse sich die Funktion bezieht.
Der Konstruktor hat den gleichen Namen wie die Klasse*/

//so sieht ein Destruktor aus:
Auto::~Auto(){
/* hier wird bestimmt was passiert wenn der
Destruktor aufgerufen wird */
  cout <<"3...2...1. Objekt wurde erfolgreich terminiert. \n I will be back."<< endl;
}

/*In der Main-Funktion instanziieren(erzeugen) wir ein Objekt aus der Klasse Auto*/
int main()
{
    Auto bmw(4); //Hier wird das Objekt erzeugt. Der Compiler ruft hier implizit den Konstruktor auf. 
    return 0;
}

Hat dir der Inhalt gefallen?

Falls du mehr zu Themen der Informatik lesen willst, kannst du die Suche dafür verwenden:

Du bist der Meinung, das war der Beste Beitrag zum Thema Informatik den du jemals gelesen hast? Dann ist die einzig logische Schlussfolgerung, diesen Beitrag mit deinen Kommilitonen zu teilen. Oder auch nicht mach was du willst, ich bin nicht dein Dad.