Destruidor virtual em c ++
Depois de falar sobre o OOP, construtores e destruidores, vamos agora falar sobre destruidores virtuais. Os destruidores virtuais, como o nome especificam, destruir o objeto. Temos uma classe base e uma classe derivada derivada da classe base. Ambas as classes têm seus construtores e destruidores. O destruidor virtual libera a reminiscência que são atribuídos através do objeto de classe derivada enquanto excluíam os objetos da classe derivada usando um ponteiro da classe base com a palavra -chave "virtual".
Por que usamos o destruidor virtual?
Quando a execução das funções do membro da classe é realizada ou a execução do método principal () está prestes a terminar, o destruidor é automaticamente chamado para libertar a memória que é alocada durante a criação do objeto. Agora, por que usamos um destruidor virtual? Quando a classe base é excluída que aponta para a classe derivada, o ponteiro (*) é usado aqui. O destruidor da classe base é chamado apenas durante este processo. O destruidor de classe derivado não é chamado, o que leva a problemas. Um deles é um problema de vazamento de memória. Para evitar esse problema e tornar nosso código seguro, praticamente destruímos os objetos para liberar o espaço de memória que foi alocado durante a criação de objetos, excluindo o destruidor da classe base.
Exemplo básico C ++ sem destruidor virtual
Vamos ver como o programa funciona sem um destruidor virtual com um programa simples que exclui o ponteiro.
Código:
#incluirusando namespace std;
Classe parent_class0
público:
Parent_class0 ()
cout<< "Parent Class Constructor" <
cout<< "Parent Class Destructor" <
Classe Child_1: Public Parent_class0
público:
Child_1 ()
cout<< "Child Class Constructor" <
cout<< "Child Class Destructor" <
int main ()
Parent_class0*ponteiro = new Child_1 ();
excluir ponteiro;
retornar 0;
Este código explica como o código é executado sem um destruidor virtual. Primeiro de tudo, crie uma classe chamada "parent_class0" que será a classe pai. Dentro desta classe, crie um construtor e destruidor. Como sabemos, o construtor e o destruidor são nomeados da mesma forma que a classe. O destruidor é representado de maneira semelhante ao construtor, mas possui um símbolo (~) que o diferencia do construtor. Dentro do construtor e destruidor, imprima uma mensagem usando “cout<<”. Now, create another class which is “Child_1”. This class is derived from the parent class, “Parent_Class0”. The derived class has its constructor and destructor that contain a message to print on the output screen.
No método main (), criamos uma instância do "parent_class0" e atribuímos uma classe derivada a ele. O ponto crucial a lembrar neste caso é que utilizamos um ponteiro para recuperar a classe pai. Quando entra na classe pai, ele executa o construtor da classe pai. Então, ele vai para a classe infantil e executa seu construtor. Antes de executar o destruidor da classe infantil, ele deve executar o destruidor da classe dos pais. O compilador executa o destruidor da classe pai e encerra a classe sem executar o destruidor de uma classe infantil. Esse é o problema; não libera a memória da aula da criança. Representa o construtor de uma classe pai, o construtor de uma classe infantil e o destruidor de uma classe pai. Isso mostra que o destruidor de uma classe infantil não é executado. Após essa execução, excluímos o ponteiro na função principal ().
Saída:
Exemplo de C ++ com destruidor virtual
Vamos discutir o destruidor virtual com um código simples para diferenciar como ele funciona com e sem um destruidor virtual.
Código:
#incluirusando namespace std;
Classe parent_class0
público:
Parent_class0 ()
cout<< "Parent Class Constructor" <
cout<< "Parent Class Destructor" <
Classe Child_1: Public Parent_class0
público:
Child_1 ()
cout<< "Child Class Constructor" <
cout<< "Child Class Destructor" <
int main ()
Parent_class0*ponteiro = new Child_1 ();
excluir ponteiro;
retornar 0;
O primeiro programa explicou o problema que estamos enfrentando sem um destruidor virtual. Agora, este código resolverá esse problema usando um destruidor virtual. Primeiro, copie o primeiro código e basta adicionar uma palavra -chave em dois lugares neste programa. Essa palavra é "virtual". Insira esta palavra com o destruidor da classe pai, "parent_class0". Da mesma forma, mencione isso com o destruidor da classe infantil, que é "criança_1" que é derivada da classe pai. Essa palavra -chave "virtual" faz um pouco de mudança e executa o destruidor da classe infantil "Child_1" primeiro. Em seguida, ele executa o destruidor da classe pai, "parent_class0". O restante do programa opera o mesmo que opera sem um destruidor virtual. Ao adicionar este pequeno pedaço de código, podemos salvar nossa memória de vazamento. Agora, ele exibe quatro mensagens no console. Primeiro, o construtor de uma classe pai, depois o construtor de uma classe infantil, o destruidor de uma classe infantil e o destruidor de uma classe de pais. No final, excluímos o ponteiro dentro do método Main ().
Saída:
Exemplo C ++ de destruidor virtual puro
Neste código, falaremos sobre o destruidor virtual puro, como ele funciona e como é diferente de um destruidor virtual.
Código:
#incluirclasse parent_0
público:
virtual ~ parent_0 () = 0;
;
Parent_0 :: ~ pai_0 ()
std :: cout<< "Hello I am Pure Destructor. You Called Me!";
classe Child_0: Public Parent_0
público:
~ Child_0 () std :: cout<< "Derived destructor is here\n";
;
int main ()
Parent_0* ptr_0 = new Child_0 ();
exclua ptr_0;
retornar 0;
A classe pai "parent_0" é criada na primeira etapa do código. Dentro dele, crie o destro virtual dos pais e atribua -o com 0. Isso define o destruidor virtual ao destruidor virtual puro, o que significa que a classe pai agora é abstrata e não podemos criar as instâncias desta classe. Fora da classe pai “Parent_0”, defina os destruidores e std :: cout. O texto necessário é mostrado utilizando o std :: cout. Em seguida, deriva uma classe "Child_0" da classe pai e defina seu destruidor. Dentro do destruidor, imprima uma mensagem. Na função Main (), crie o ponteiro da classe pai e atribua a classe infantil a ela.
O compilador vai para a classe pai "Parent_0". Quando o ponteiro é criado, seu construtor é chamado automaticamente. Então, o compilador entra na classe infantil para invocar seu construtor. Após a execução bem -sucedida do construtor, ele executa o destruidor de uma classe infantil “Child_0”. Em seguida, ele executa o destruidor de uma classe pai. Dessa forma, podemos fazer um destruidor virtual puro. Não é incentivado a utilizá -lo porque, ao empregar esse método, a classe pai se torna abstrata, o que o torna inútil. A metodologia que é usada principalmente é destruidor virtual e é uma boa prática.
Saída:
Conclusão
Aprendemos sobre o destruidor virtual, começando do conceito de OOP até a mudança em direção aos construtores e destruidores. Depois de explicar tudo isso, discutimos sobre o destruidor virtual em detalhes com exemplos de codificação e destruidor virtual puro. Antes de explicar o destruidor virtual, devemos saber sobre os construtores, destruidores e herança. Em herança, herdamos as classes de uma classe pai. As aulas infantis podem ser mais de uma, mas a classe pai é apenas uma. Destrutores virtuais e destruidores virtuais puros são aplicados em herança para salvar do vazamento de memória. Do exemplo básico ao exemplo avançado, abordamos tudo o que você deve saber para começar a usar e praticamente destruir a memória da classe derivada.