Tutoriales

Destructor para lista enlazada C++

Una lista enlazada es una estructura de datos secuenciales cuyos miembros no se retienen en la misma ubicación de memoria. En otras palabras, una lista enlazada se compone de nodos, todos los cuales tienen un marco de datos y un enlace a otro nodo de la lista. Una lista enlazada se puede declarar como una estructura o una clase en C++. Cuando se elimina cualquier objeto de la clase y sus elementos, los destructores suelen utilizarse para reasignar el almacenamiento y realizar algunas operaciones. El destructor se invoca cuando un objeto de la clase alcanza su acceso o se descarta deliberadamente.

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

Destructor definido implícitamente

Si una lista enlazada no tiene un destructor definido por el usuario, el compilador especificará un destructor como miembro del enlace. Una lista enlazada no estática no será devastada por un destructor definido implícitamente. La lista enlazada de base virtual o explícita de un destructor definido implícitamente 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 definido implícitamente que no se elimina, se especifica implícitamente. El cuerpo de este destructor declarado implícitamente está en blanco.

#incluir

usando el espacio de nombres estándar;
estructura Enlace
{
En t d;
Enlace* Siguiente;
};
lista de enlaces de clase
{
privado:
Enlace* primero;
público:
lista de enlaces()
{ primero = NULO; }
~lista de enlaces();
vacío valor adicional(En t a);
vacío monitor();
};
vacío lista de enlaces::valor adicional(En t a)
{
Enlace* nuevo enlace = nuevo enlace;
nuevo enlace->d = a;
nuevo enlace->Siguiente = primero;
primero = nuevo enlace;
}
vacío lista de enlaces::monitor()

LEER  ᐅ Cómo instalar Postman en Linux [PASO A PASO]

Al comienzo del programa, incluiremos un archivo de encabezado . Junto con esto, también se utiliza el espacio de nombres estándar. Declaramos un miembro de la lista llamado ‘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 ‘lista de enlaces’. Es una lista de enlaces. Su puntero al primer enlace se establece como privado y el constructor se establece públicamente.

El constructor de la «lista de enlaces» no tiene ningún parámetro. Proporcionamos el enlace ‘primero’ al valor ‘NULL’. Luego 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. Así que aplicamos la función void addval(). Esta función contiene el conjunto de datos requerido como argumento.

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

{
Enlace* Actual = primero;
tiempo( Actual != NULO )
{
cout<final<d;
Actual = Actual->Siguiente;
}
}
lista de enlaces::~lista de enlaces()
{
Enlace* Actual = primero;
tiempo( Actual != NULO )
{
Enlace* temperatura = Actual;
Actual = Actual->Siguiente;
eliminar temperatura;
}
}
En t principal()
{
lista de enlaces l;
yovalor adicional(11);
yovalor adicional(22);
yovalor adicional(33);
yovalor adicional(44);
yomonitor();
cout<final;
devolver ;
}

Además de esto, colocamos el puntero ‘*actual’ en el primer enlace. Aplicamos el ciclo while aquí. El destructor se aplica en la ‘lista de enlaces’. De manera similar, volvemos a establecer el puntero en el primer elemento del enlace y salimos del ú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’. Se está iniciando el cuerpo de la función main(). Los datos de esta lista enlazada se almacenan en una variable ‘l’. Ahora insertamos por separado cuatro valores aleatorios en la lista con la ayuda de la función l.addval(). Empleamos el método l.display() para mostrar la lista enlazada completa. Antes de ingresar el comando ‘return o’, agregamos ‘endl’. Simplemente imprime los valores de la lista enlazada en líneas separadas.

Uso de Trivial Destructor

El destructor trivial no se aborda directamente. Serán declarados automáticamente o declarados explícitamente. Este destructor no es dinámico; por lo tanto, el destructor de la clase padre no es dinámico. 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 de forma inversa a los constructores. Los elementos que tienen destructores triviales no necesitarían una declaración de eliminación para ser descartados; más bien, se pueden reasignar.

#incluir

usando el espacio de nombres estándar;

viajes en clase {

público:

Viaje()

{

cout< «Constructor invocado para clase de viaje» <final;

}

~Viajes()
{
cout< «Destructor invocado para la clase de viaje» <final;
}
};
coche de clase {
público:
Coche()
{
cout< «Constructor invocado para clase de automóvil» <final;
}

~Coche()
{
cout< «Destructor invocado para la clase de coche» <final;
}
};

En t principal(vacío)
{
viaje t1;
coche c2;
devolver ;
}

En primer lugar, integramos el archivo de cabecera. y espacio de nombres estándar. Declaramos una lista enlazada como una clase ‘Viaje’. Definimos el constructor de esta clase públicamente. Hemos estado utilizando el comando ‘cout’ para imprimir el texto. Luego también se construye el destructor ‘~Travel()’ de la clase. Para mostrar la línea, ingresamos nuevamente la instrucción ‘cout’. Creamos una segunda clase del programa llamada ‘Car’.

De la misma forma, definimos el constructor y destructor de esta clase. Se está llamando a la función main(). El objeto ‘t1’ de la clase ‘Viaje’ y el objeto ‘c2’ de la clase ‘Coche’ han sido creados dentro del cuerpo de la función main(). Tenemos que ingresar el comando ‘return 0’ para terminar 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 main(). Entonces, cada vez que el objeto ‘c2’ de la clase ‘Car’ se crea en la segunda línea de la función main(), el compilador llama implícitamente al constructor relacionado con el objeto ‘c2’.

Los destructores a menudo se invocan en la secuencia opuesta a los constructores. Una vez que finaliza el contexto de la función main(), primero se llama al destructor asociado con el objeto ‘c2’. Posteriormente, se invoca el destructor asociado al objeto ‘t1’.

Conclusión

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

LEER  ¡Ya puedes jugar muchos juegos en Linux! | Vino 6.0

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba