No entanto, um destruidor virtual poderia existir. Aqui, mostraremos o que acontece quando criamos um construtor virtual em C++, bem como o funcionamento do destruidor virtual em vez do construtor virtual.
Exemplo 1:
Vamos criar o construtor virtual e iniciar nosso código colocando o arquivo de cabeçalho “iostream”. Este arquivo de cabeçalho é para as funções nele declaradas como “cin” e “cout”. Depois disso, adicionamos o namespace “std”, portanto não podemos adicionar este “std” com todas as funções em nosso código. Depois disso, criamos uma classe que é a classe base do nosso código com o nome “my_base” e depois adicionamos “public” para criar o construtor virtual.
O construtor virtual é criado aqui colocando a palavra-chave “virtual”. Dentro deste construtor virtual, colocamos uma instrução “cout”. Abaixo disso, criamos uma função chamada “show” na qual utilizamos o “cout” novamente. Depois disso, criamos uma classe derivada desta classe base com o nome “my_derived” e então estabelecemos o construtor “my_derived()” no campo “public”. Inserimos uma instrução “cout” neste construtor “my_derived()”. Abaixo dela construímos uma função chamada “show” onde utilizamos mais uma vez o “cout”.
Agora, após invocar “main()”, criamos um ponteiro da classe base com o nome “my_ptr” e também criamos o objeto da classe derivada que é “Obj_d”. Depois disso, atribuímos o endereço de “Obj_d” a “my_ptr”. Em seguida, chamamos a função “show()” através de “my_ptr”.
Código 1:
#include
usando espaço para nome padrão ;
aula minha_base
{
público :
virtual minha_base ( )
{
corte << 'Aqui está minha classe base' << fim ;
}
vazio mostrar ( )
{
corte << 'a função show da classe base' << fim ;
}
} ;
aula meu_derivado : público minha_base
{
público :
meu_derivado ( )
{
corte << 'Aqui está minha classe derivada' << fim ;
}
vazio mostrar ( )
{
corte << 'a função show da classe derivada' < mostrar ( ) ;
}
Saída:
Aqui mostra uma mensagem de erro informando que o construtor não pode ser declarado virtual na programação C++. Assim, podemos ver que C++ não nos permite gerar o construtor virtual, mas podemos criar o destruidor virtual.
Exemplo 2:
Vamos resolver o problema anterior e criar o destruidor virtual neste código. Após declarar a classe “new_base”, colocamos o construtor “public” no qual criamos o destruidor virtual adicionando “virtual ~” com a “new_base”. Inserimos uma instrução “cout” neste destruidor virtual. Abaixo dela, construímos uma função chamada “show” que faz uso do “cout”. A seguir, criamos uma classe derivada que é “new_derived” desta classe base “new_base” e construímos o destruidor “new_derived()” no campo “public”. Este destruidor “new_derived()” agora tem uma instrução “cout” adicionada a ele.
Abaixo dela, criamos uma função chamada “show” que usa a instrução “cout” novamente. Após chamar a função “main()”, produzimos agora um objeto da classe derivada “obj_d”, bem como um ponteiro da classe base denominado “ptr1”. Em seguida, atribuímos o endereço “obj_d” ao “ptr1”. A seguir, o método “show()” é invocado usando “ptr1”.
Código 2:
#includeusando espaço para nome padrão ;
aula nova_base
{
público :
virtual ~nova_base ( )
{
corte << 'O destruidor da classe base está aqui' << fim ;
}
vazio mostrar ( )
{
corte << 'A função show da classe base' << fim ;
}
} ;
aula novo_derivado : público nova_base
{
público :
~ novo_derivado ( )
{
corte << 'O destruidor de classe derivada está aqui' << fim ;
}
vazio mostrar ( )
{
corte << 'A função show da classe base' < mostrar ( ) ;
}
Saída:
Este programa usa um objeto ponteiro de “new_base” que aponta para a classe derivada “obj_d”. Assim, ele chama primeiro o método “show()” da classe “new_base”. Em seguida, ele chama o método “~new_derived()” da classe “new_derived” e exibe “~new_base” da classe base.
Exemplo 3:
Aqui está outro código para gerar o construtor “virtual”. Após incluir o namespace “iostream” e “std”, geramos uma classe “B”. Abaixo disso, criamos o construtor “público” que é “B()” e depois geramos o “cout”. As funções construtora e destruidora são definidas utilizando um especificador de acesso “público” no qual qualquer objeto da classe pode chamar.
Agora, também criamos o destruidor “~B()” desta classe base no qual utilizamos o “cout” novamente. Então, criamos a classe “D” que é a classe derivada da classe base “B” e colocamos o “público” aqui. Dentro deste “público”, criamos o construtor e também o destruidor da classe derivada com os nomes “D()” e “~D”, respectivamente. Ambos contêm o “cout” dentro deles. Agora, temos a função “main()”. Após chamar esta função, geramos o objeto ponteiro da classe base.
Então, usamos a palavra-chave “delete” e colocamos “base_ptr” aqui. Nesse caso, o espaço do destruidor é excluído chamando o objeto ponteiro da classe base.
Código 3:
#includeusando espaço para nome padrão ;
aula B
{
público :
B ( )
{
corte << 'Construtor da classe Base' << fim ;
}
~B ( )
{
corte << 'Destruidor da classe Base' << fim ;
}
} ;
aula D : público B
{
público :
D ( )
{
corte << 'Construtor da classe Derivada' << fim ;
}
~D ( )
{
corte << 'Destruidor da classe derivada' << fim ;
}
} ;
interno principal ( )
{
B * base_ptr = novo D ;
excluir base_ptr ;
}
Saída:
O resultado mostra que ele usa um objeto ponteiro que aponta para a classe “B” na função principal. Assim, ele chama primeiro o “construtor()” da classe “B”. Em seguida, ele chama o “construtor()” da classe “D”. O objeto ponteiro mantido pelos destruidores das classes “B” e “D” é então excluído. Sem invocar o destruidor da classe “D” dentro do programa, o ponteiro da classe “B” apenas elimina o destruidor da classe “B”. Como resultado, a memória do programa está corrompida.
Conclusão
Discutimos o conceito de “construção virtual” na programação C++. Exploramos que não podemos criar o construtor virtual em C++, mas podemos criar o destruidor virtual em nossos códigos. Aqui, mostramos o que aconteceu quando criamos o construtor virtual na programação C++ e o funcionamento do destruidor virtual em nossos códigos. Aprendemos que o construtor não pode ser virtual, mas podemos gerar o destruidor virtual em nossa classe. Demonstramos alguns exemplos e explicamos esses códigos detalhadamente neste guia.