Klassendestruktor unter Verwendung des Tilde-Operator in C++ definieren

1. Verwenden den Tilde-Operator ~ zur Deklaration des Klassendestruktors in C++
2. Code ausführen, bevor das Klassenobjekt in C++ zerstört wird

Dieser Artikel demonstriert mehrere Methoden, wie man den Klassendestruktor unter Verwendung den Tilde-Operator in C++ definiert.

Verwenden den Tilde-Operator ~ zur Deklaration des Klassendestruktors in C++

Der Destruktor ist eine spezielle Member-Funktion, die die Deallokation der Ressourcen des Klassenobjekts übernimmt. Im Gegensatz zu den Klassenkonstruktoren gibt es nur eine Destruktorfunktion für eine bestimmte Klasse. Der Klassendestruktor wird mit dem gleichen Namen wie die Klasse plus dem vorangestellten Tilde-Operator ~ deklariert.

In den meisten Fällen muss der Destruktor der Klasse definiert werden, wenn es Datenmitglieder gibt, die auf dynamischem Speicher allokiert werden müssen. Der Code sollte diese Mitglieder explizit in der Destruktorfunktion deallokieren. Das folgende Beispiel demonstriert die Klasse CustomString, die nur der Wrapper für die Klasse std::string ist. Die Idee ist, eine Klasse mit einem Konstruktor zu definieren, der Speicher an einem str-Zeiger alloziert, was impliziert, dass die Klasse die Definition eines Destruktors benötigt. Beachten Sie, dass CustomString zwei Konstruktoren hat - einer davon ist ein Kopierkonstruktor.

#include <iostream>
#include <string>
#include <vector>

using std::cout;
using std::endl;
using std::string;
using std::vector;

class CustomString {
 public:
  explicit CustomString(const string &s = string()) : str(new string(s)) {}

  CustomString(const CustomString &p) : str(new string(*p.str)) {}

  ~CustomString() { delete str; }

  string &getString() { return *str; };

 private:
  string *str;
};

int main() {
  CustomString str1("Hello There!");
  CustomString str2(str1);

  cout << "str1: " << str1.getString() << endl;
  cout << "str2: " << str2.getString() << endl << endl;
}

Ausgabe:

str1: Hello There!
str2: Hello There!

Code ausführen, bevor das Klassenobjekt in C++ zerstört wird

Wie die vorherige Methode zeigt, ist ein Klassendestruktor dafür verantwortlich, den Speicher der Datenmitglieder aufzuräumen. Allerdings handelt es sich bei den Klassenmitgliedern oft nur um die üblichen Datentypen, die auf dem Programmstapel deklariert sind. In diesem Fall wird der Destruktor möglicherweise nicht explizit vom Programmierer deklariert, sondern der Compiler definiert den sogenannten synthetisierten Destruktor.

Im Allgemeinen werden die Klassenmitglieder zerstört, nachdem der Funktionscode des Destruktors ausgeführt wurde; so können wir demonstrieren, wie die Klasseninstanz StringArray aus dem Gültigkeitsbereich geht und damit den entsprechenden Text auf der Konsole ausgibt.

#include <iostream>
#include <string>
#include <vector>

using std::cout;
using std::endl;
using std::string;
using std::vector;

class StringArray {
 public:
  StringArray() : vec(), init(new int[10]){};
  ~StringArray() {
    delete[] init;
    cout << "printed from destructor" << endl;
  }

  string getString(int num) {
    if (vec.at(num).c_str()) {
      return vec.at(num);
    } else {
      return string("NULL");
    }
  };

  void addString(const string& s) { vec.push_back(s); };

  uint64_t getSize() { return vec.size(); };

 private:
  vector<string> vec;
  int* init;
};

int main() {
  StringArray arr;

  arr.addString("Hello there 1");
  arr.addString("Hello there 2");

  cout << "size of arr: " << arr.getSize() << endl;
  cout << "arr[0]: " << arr.getString(0) << endl;
}

Ausgabe:

size of arr: 2
arr[0]: Hello there 1
printed from destructor