Destrutor para a lista vinculada C ++

Uma lista vinculada é uma estrutura de dados seqüencial com membros não retidos no mesmo local de memória. Em outras palavras, uma lista vinculada é composta de nós, todos os quais têm um quadro de dados e um link para outro nó na lista. Uma lista vinculada pode ser declarada como uma estrutura ou uma classe em C++. Quando qualquer objeto da classe e seus elementos são eliminados, os destruidores são normalmente utilizados para realocar o armazenamento e executar algumas operações. O destruidor é invocado quando um objeto da classe atinge seu acesso ou é deliberadamente descartado.

Um destruidor não tem parâmetros e não retorna nada. Um destruidor nunca foi chamado explicitamente. O destruidor terá um título semelhante ao da classe, mas tem uma tild (~) antes dela. Se uma lista não for mais utilizada em todo o programa, ela será excluída usando um destruidor, porque o espaço de armazenamento adotado por cada nó poderá ser fornecido ao sistema e reprocessado. O destruidor da lista vinculado pode excluir a lista. Vamos falar em detalhes:

Destruidor implicitamente definido

Se uma lista vinculada não tiver destruidor definido pelo usuário, o compilador especificará um destruidor como um membro do link. Uma lista vinculada não estática não será devastada por um destruidor implicitamente definido. Uma lista explícita ou virtual vinculada a um destruidor implicitamente definido não pôde ser destruído. O destruidor implicitamente especificado é virtual, e o método de realocação retorna um procedimento indefinido, terminado ou isolado. Quando um compilador localiza um destruidor implicitamente definido que não é removido, é especificado implicitamente. O corpo desse destruidor implicitamente declarado está em branco.

#incluir
usando namespace std;
Link de estrutura

int d;
link* a seguir;
;
Classe LinkList

privado:
link* primeiro;
público:
linklist ()
primeiro = null;
~ linkList ();
void addVal (int a);
Void Display ();
;
Void Linklist :: addVal (int a)

link* newlink = novo link;
newlink-> d = a;
newlink-> próximo = primeiro;
primeiro = newlink;

Void Linklist :: Display ()

No início do programa, incluiremos um arquivo de cabeçalho . Junto com isso, o espaço para nome padrão também é utilizado. Declaramos um membro da lista denominada 'link'. A variável 'd' para armazenar o conjunto de dados está sendo inicializada. Criamos um ponteiro para a próxima lista. Aqui construímos a classe denominada 'linklist'. É uma lista de links. Seu ponteiro para o primeiro link é definido como privado, e o construtor é definido publicamente.

O construtor da "linklist" não tem parâmetro. Fornecemos o link 'primeiro' para o valor 'nulo'. Então usamos o destruidor '~ linkList ()'. Em C ++, um destruidor é um método que remove um elemento. Não possui parâmetros de entrada nem tipo de saída. Estaremos adicionando os elementos à lista de links. Então, aplicamos a função Void AddVal (). Esta função contém o conjunto de dados necessário como argumento.

Estamos usando a função void Display () para exibir todos os links. Aqui criamos um novo link. Fornecemos o conjunto de dados para o novo link usando o operador (->). Este operador aponta para o próximo link. O primeiro elemento da lista de links é apontado para o novo link. Temos que exibir a lista vinculada especificada usando a função Display ().

link* atual = primeiro;
while (atual != Nulo)

cout<Current = Current-> Next;


linklist :: ~ linklist ()

link* atual = primeiro;
while (atual != Nulo)

link* temp = atual;
Current = Current-> Next;
excluir temp;


int main ()

linklist l;
eu.addVal (11);
eu.addVal (22);
eu.addVal (33);
eu.addVal (44);
eu.mostrar();
cout<retornar 0;

Além disso, definimos o ponteiro '*atual' para o primeiro link. Aplicamos o loop while aqui. O destruidor é aplicado na 'linklist'. Da mesma forma, novamente definimos o ponteiro para o primeiro elemento do link e saímos no último elemento do link usando o loop 'while'. Inicializamos uma nova variável, 'Temp', para armazenar o ponteiro do primeiro link. O operador (->) é usado para adquirir o ponteiro para o novo link.

Portanto, excluímos a variável 'Temp'. O corpo da função principal () está sendo iniciado. Os dados desta lista vinculada são armazenados em uma variável 'L'. Agora inserimos separadamente quatro valores aleatórios na lista com a ajuda do L.função addVal (). Nós empregamos o L.Método Display () para mostrar toda a lista vinculada. Antes de entrar no comando 'retornar o', adicionamos 'endl'. Apenas imprime os valores da lista vinculada em linhas separadas.

Uso de destruidor trivial

O destruidor trivial não é abordado diretamente. Eles serão declarados automaticamente ou explicitamente declarados. Este destruidor não é dinâmico; Portanto, o destruidor da classe pai não é dinâmico. Os destruidores são triviais em todas as classes abstratas primárias. Os destruidores são triviais para alguns objetos de dados não estáticos ou matrizes da subclasse. Os destruidores são frequentemente invocados inversamente que os construtores são. Elementos com destruidores triviais não precisariam de uma estatura de exclusão para ser descartada; Em vez disso, eles podem ser realocados.

#incluir
usando namespace std;
classe Travel
público:
Viagem()

cout<< "Constructor Invoked for Travel class" <
~ Travel ()

cout<< "Destructor Invoked for Travel class" <
;
Classe Car
público:
Carro()

cout<< "Constructor Invoked for Car class" <
~ Carro ()

cout<< "Destructor Invoked for Car class" <
;
int main (vazio)

Viagem T1;
Carro c2;
retornar 0;

Primeiro de tudo, integramos o arquivo de cabeçalho e o namespace padrão. Declaramos uma lista vinculada como uma classe 'viagens'. Definimos o construtor desta classe publicamente. Temos utilizado o comando 'cout' para imprimir o texto. Então o destruidor '~ Travel ()' da classe também é construído. Para exibir a linha, novamente entramos na declaração 'cout'. Criamos uma segunda classe do programa chamado 'Car'.

Da mesma maneira, definimos o construtor e o destruidor desta classe. A função principal () está sendo chamada. O objeto 'T1' da classe 'viagens' e objeto 'c2' de classe 'carro' foram criados dentro do corpo da função principal (). Temos que entrar no comando 'retornar 0' para encerrar o programa.

O construtor de um objeto denominado 'T1' é instantaneamente invocado antes de construir o objeto na primeira seção da função principal (). Portanto, sempre que o objeto 'C2' da classe 'carro' é feito na segunda linha de função main (), o compilador chama implicitamente o construtor relacionado ao objeto 'C2'.

Os destruidores são frequentemente invocados na sequência oposta como construtores. Uma vez que o contexto da função principal () termina, o destruidor associado ao objeto 'C2' é chamado primeiro. Depois, o destruidor associado ao objeto 'T1' é invocado.

Conclusão

Neste artigo, discutimos o destruidor de listas vinculadas em C++. Os destruidores nunca serão explicitamente invocados. Os destruidores não têm uma declaração de retorno. Podemos implementar um destruidor para revelar o armazenamento pouco antes da exclusão da lista vinculada quando uma lista inclui um ponteiro para a memória do sistema. Para minimizar os transbordamentos de buffer, isso pode ser realizado.