Definir Destruidor de Classe Utilizando o Operador Tilde em C++

  1. Utilizar o operador Tilde ~ para declarar o destruidor de classes em C++
  2. Executar código antes que o objecto da classe seja destruído em C++

Este artigo irá demonstrar múltiplos métodos sobre como definir o destruidor de classes utilizando o operador de til em C++.

Utilizar o operador Tilde ~ para declarar o destruidor de classes em C++

O destruidor é uma função especial de membro que trata da desalocação dos recursos do objecto de classe. Ao contrário dos construtores de classes, tem apenas uma função de destruidor para uma determinada classe. O destruidor de classe é declarado com o mesmo nome da classe mais o prefixo ~ operador til.

Na maioria dos casos, o destruidor da classe é necessário para ser definido se houver membros de dados que necessitem de ser alocados na memória dinâmica. O código deve desalocar explicitamente estes membros na função destruidora. O exemplo seguinte demonstra a classe CustomString que é apenas o invólucro para o std::string. A ideia é definir uma classe com um construtor que atribui memória a um ponteiro str, o que implica que a classe requer que o destrutor seja definido. Note-se que CustomString tem dois construtores - um deles é um construtor de cópias.

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

}

Resultado:

str1: Hello There!
str2: Hello There!

Executar código antes que o objecto da classe seja destruído em C++

Como o método anterior mostra, um destruidor de classe é responsável pela limpeza da memória dos membros dos dados. Embora, os membros da classe sejam frequentemente apenas os tipos de dados habituais declarados na pilha de programas. Nesse caso, o destruidor pode não ser declarado explicitamente pelo programador, mas o compilador define o chamado destruidor sintetizado.

Geralmente, os membros da classe são destruídos após o código da função destruidora ser executado; assim, podemos demonstrar como a instância da classe StringArray sai do âmbito e, portanto, imprimir para a consola o texto correspondente.

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

Resultado:

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

Artigo relacionado - C++ Class

  • Usar Membros da Classe Privada vs Classe Protegida em C++