Définir le destructeur de classe en utilisant l'opérateur Tilde en C++

  1. Utiliser l’opérateur tilde ~ pour déclarer le destructeur de classe en C++
  2. Exécution du code avant que l’objet de la classe ne soit détruit en C++

Cet article présente plusieurs méthodes pour définir le destructeur de classe à l’aide de l’opérateur tilde en C++.

Utiliser l’opérateur tilde ~ pour déclarer le destructeur de classe en C++

Le destructeur est une fonction spéciale du membre qui s’occupe de la désaffectation des ressources de l’objet de classe. Contrairement aux constructeurs de classe, il n’a qu’une seule fonction de destructeur pour une classe donnée. Le destructeur de classe est déclaré avec le même nom que la classe plus le préfixe ~ tilde operator.

Dans la plupart des cas, le destructeur de classe doit être défini s’il y a des membres de données qui doivent être alloués sur la mémoire dynamique. Le code doit explicitement désallouer ces membres dans la fonction de destructeur. L’exemple suivant montre la classe CustomString qui n’est que l’habillage de la chaîne std::string. L’idée est de définir une classe avec un constructeur qui alloue la mémoire à un pointeur str, ce qui implique que la classe nécessite que le destructeur soit défini. Notez que CustomString a deux constructeurs - l’un d’eux est un constructeur de copie.

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

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

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;

}

Production :

str1: Hello There!
str2: Hello There!

Exécution du code avant que l’objet de la classe ne soit détruit en C++

Comme le montre la méthode précédente, un destructeur de classe est chargé de nettoyer la mémoire des membres des données. Cependant, les membres de la classe ne sont souvent que les types de données habituels déclarés sur la pile du programme. Dans ce cas, le destructeur peut ne pas être déclaré explicitement par le programmeur, mais le compilateur définit le destructeur dit synthétisé.

Généralement, les membres de la classe sont détruits après l’exécution du code de la fonction destructrice ; ainsi, nous pouvons démontrer comment l’instance de classe StringArray sort du champ d’application et donc imprimer à la console le texte correspondant.

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

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

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

Production :

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

Article connexe - C++ Class

  • Utiliser des membres de classe private ou protected en C++