Definisci il distruttore di classi usando l'operatore Tilde in C++

1. Usa l’operatore Tilde ~ per dichiarare il distruttore di classe in C++
2. Eseguire il codice prima che l’oggetto della classe venga distrutto in C++

Questo articolo illustrerà più metodi su come definire il distruttore di classe utilizzando l’operatore tilde in C++.

Usa l’operatore Tilde ~ per dichiarare il distruttore di classe in C++

Il distruttore è una funzione membro speciale che gestisce la deallocazione delle risorse dell’oggetto classe. A differenza dei costruttori di classi, ha solo una funzione distruttore per una data classe. Il distruttore di classe è dichiarato con lo stesso nome della classe più il prefisso ~ operatore tilde.

Nella maggior parte dei casi, è necessario definire il distruttore della classe se sono presenti membri di dati che devono essere allocati sulla memoria dinamica. Il codice dovrebbe rilasciare esplicitamente questi membri nella funzione distruttore. L’esempio seguente mostra la classe CustomString che è solo il wrapper per std::string. L’idea è di definire una classe con un costruttore che alloca memoria a un puntatore str, il che implica che la classe richiede la definizione del distruttore. Nota che CustomString ha due costruttori - uno di loro è un costruttore di copia.

#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;
}

Produzione:

str1: Hello There!
str2: Hello There!

Eseguire il codice prima che l’oggetto della classe venga distrutto in C++

Come mostra il metodo precedente, un distruttore di classe è responsabile della pulizia della memoria dei membri dei dati. Tuttavia, i membri della classe sono spesso solo i soliti tipi di dati dichiarati nello stack del programma. In tal caso, il distruttore potrebbe non essere dichiarato esplicitamente dal programmatore, ma il compilatore definisce il cosiddetto distruttore sintetizzato.

In genere, i membri della classe vengono eliminati dopo l’esecuzione del codice della funzione distruttore; quindi, possiamo dimostrare come l’istanza della classe StringArray esca dallo scope e quindi stampi sulla console il testo corrispondente.

#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;
}

Produzione:

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