Destructor para la lista vinculada C ++

Una lista vinculada es una estructura de datos secuencial con miembros no retenidos en la misma ubicación de memoria. En otras palabras, una lista vinculada está compuesta por nodos, todos los cuales tienen un marco de datos y un enlace a otro nodo en la lista. Una lista vinculada puede declararse como una estructura o una clase en C++. Cuando se eliminan cualquier objeto de la clase y sus elementos, los destructores generalmente se utilizan para reasignar el almacenamiento y realizar algunas operaciones. El destructor se invoca cuando un objeto de la clase alcanza su acceso o se descartan deliberadamente.

Un destructor no tiene parámetros y no devuelve nada. Un destructor nunca ha sido llamado explícitamente. El destructor tendrá un título similar al de la clase, pero tiene un tild (~) antes. Si una lista ya no se utiliza en todo el programa, se eliminará mediante el uso de un destructor porque entonces el espacio de almacenamiento absorbido por cada nodo podría proporcionarse al sistema y reprocesarse. El destructor de la lista vinculada puede eliminar la lista. Hablemos en detalle:

Destructor implícitamente definido

Si una lista vinculada no tiene destructor definido por el usuario, el compilador especificará un destructor como miembro de enlace. Una lista vinculada no estática no será devastada por un destructor implícitamente definido. La lista vinculada de base explícita o virtual de un destructor implícitamente definido no se pudo destruir. El destructor especificado implícitamente es virtual, y el método de reasignación devuelve un procedimiento indefinido, terminado o aislado. Cuando un compilador localiza un destructor implícitamente definido que no se elimina, se especifica implícitamente. El cuerpo de este destructor implícitamente declarado está en blanco.

#incluir
usando el espacio de nombres STD;
enlace de estructura

int d;
enlace* Siguiente;
;
Linklist de clase

privado:
enlace* primero;
público:
Linklist ()
Primero = nulo;
~ linklist ();
void addval (int a);
visualización vacía ();
;
Void LinkList :: AddVal (int a)

enlace* newlink = nuevo enlace;
newlink-> d = a;
newlink-> next = primero;
primero = newlink;

Void LinkList :: Display ()

Al comienzo del programa, incluiremos un archivo de encabezado . Junto con esto, el espacio de nombres estándar también se utiliza. Declaramos un miembro de la lista llamada 'enlace'. La variable 'd' para almacenar el conjunto de datos se está inicializando. Creamos un puntero para la siguiente lista. Aquí construimos la clase denominada 'LinkList'. Es una lista de enlaces. Su puntero al primer enlace se establece como un privado, y el constructor se establece públicamente.

El constructor de la "LinkList" no tiene parámetro. Proporcionamos el enlace 'primer' al valor 'nulo'. Entonces hemos usado el destructor '~ linklist ()'. En C ++, un destructor es un método que elimina un elemento. No tiene parámetros de entrada ni tipo de salida. Agregaremos los elementos a la lista de enlaces. Entonces aplicamos la función nulo addval (). Esta función contiene el conjunto de datos requerido como argumento.

Hemos estado utilizando la función Void Display () para mostrar todos los enlaces. Aquí creamos un nuevo enlace. Proporcionamos el conjunto de datos al nuevo enlace utilizando el operador (->). Este operador apunta al siguiente enlace. El primer elemento de la primera lista de enlaces se apunta al nuevo enlace. Tenemos que mostrar la lista vinculada especificada utilizando la función display ().

enlace* actual = primero;
mientras (actual != Nulo)

cout<corriente = corriente-> Next;


linklist :: ~ linklist ()

enlace* actual = primero;
mientras (actual != Nulo)

enlace* temp = actual;
corriente = corriente-> Next;
eliminar temp;


int main ()

Linklist l;
l.addval (11);
l.addval (22);
l.addval (33);
l.addval (44);
l.mostrar();
cout<regresar 0;

Además de esto, establecemos el puntero '*actual' en el primer enlace. Aplicamos el bucle while aquí. El destructor se aplica en la 'LinkList'. Del mismo modo, volvemos a configurar el puntero en el primer elemento del enlace y renunciamos en el último elemento del enlace usando el bucle 'while'. Inicializamos una nueva variable, 'temp', para almacenar el puntero del primer enlace. El operador (->) se utiliza para adquirir el puntero al nuevo enlace.

Por lo tanto, eliminamos la variable 'temp ". El cuerpo de la función principal () se está iniciando. Los datos de esta lista vinculada se almacenan en una variable 'l'. Ahora insertamos por separado cuatro valores aleatorios en la lista con la ayuda de la L.función addVal (). Empleamos la L.Método display () para mostrar toda la lista vinculada. Antes de ingresar el comando 'return o', agregamos 'endl'. Simplemente imprime los valores de la lista vinculada en líneas separadas.

Uso del destructor trivial

El destructor trivial no se aborda directamente. Serán declarados o declarados explícitamente automáticamente. Este destructor no es dinámico; Por lo tanto, el destructor de la clase principal no es dinámica. Los destructores son triviales en todas las clases abstractas primarias. Los destructores son triviales para algunos objetos de datos no estáticos o matrices de la subclase. Los destructores se invocan con frecuencia inversamente que los constructores son. Los elementos que tienen destructores triviales no necesitarían una declaración eliminada para ser descartadas; más bien, se pueden reasignar.

#incluir
usando el espacio de nombres STD;
viajes de clase
público:
Viajar()

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

cout<< "Destructor Invoked for Travel class" <
;
coche de clase
público:
Auto()

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

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

Viajar t1;
Coche C2;
regresar 0;

En primer lugar, integramos el archivo de encabezado y el espacio de nombres estándar. Declaramos una lista vinculada como una clase 'Viajes'. Definimos el constructor de esta clase públicamente. Hemos estado utilizando el comando 'cout' para imprimir el texto. Entonces el destructor '~ Travel ()' de la clase también está construido. Para mostrar la línea, nuevamente ingresamos la instrucción 'Cout'. Creamos una segunda clase del programa llamado 'automóvil'.

De la misma manera, definimos el constructor y el destructor de esta clase. La función principal () se llama. El objeto 't1' de la clase 'viajar' y objeto 'c2' de la clase 'automóvil' se ha creado dentro del cuerpo de la función principal (). Tenemos que ingresar el comando 'return 0' para finalizar el programa.

El constructor de un objeto denominado 'T1' se invoca instantáneamente antes de construir el objeto en la primera sección de la función principal (). Entonces, cada vez que el objeto 'C2' de la clase 'Car' se realiza en la segunda línea de funciones Main (), el compilador llama implícitamente al constructor relacionado con el objeto 'C2'.

Los destructores a menudo se invocan en la secuencia opuesta como constructores. Una vez que termina el contexto de la función main (), el destructor asociado con el objeto 'C2' se llama primero. Posteriormente, se invoca el destructor asociado con el objeto 'T1'.

Conclusión

En este artículo, hemos discutido el destructor de listas vinculadas en C++. Los destructores nunca serán invocados explícitamente. Los destructores no tienen una declaración de devolución. Podemos implementar un destructor para revelar el almacenamiento justo antes de que la lista vinculada se elimine cuando una lista incluye un puntero a la memoria del sistema. Para minimizar los desbordamientos del búfer, esto se puede realizar.