Destructeur pour la liste liée C ++

Une liste liée est une structure de données séquentielle avec des membres non conservés dans le même emplacement de mémoire. En d'autres termes, une liste liée est composée de nœuds, qui ont tous un cadre de données et un lien vers un autre nœud dans la liste. Une liste liée peut être déclarée comme une structure ou une classe en C++. Lorsqu'au cours de la classe et de ses éléments sont éliminés, les destructeurs sont généralement utilisés pour réaffecter le stockage et effectuer certaines opérations. Le destructeur est invoqué lorsqu'un objet de la classe atteint son accès ou est délibérément rejeté.

Un destructeur n'a pas de paramètres et ne renvoie rien. Un destructeur n'a jamais été appelé explicitement. Le destructeur aura un titre similaire à la classe, mais il a un tild (~) avant lui. Si une liste n'est plus utilisée dans l'ensemble du programme, elle sera supprimée en utilisant un destructeur car alors l'espace de stockage absorbé par chaque nœud pourrait être fourni au système et retraité. Le destructeur de la liste liée peut supprimer la liste. Parlons en détail:

Destructeur implicitement défini

Si une liste liée n'a pas de destructeur défini par l'utilisateur, le compilateur spécifie un destructeur en tant que membre de lien. Une liste liée non statique ne sera pas dévastée par un destructeur implicitement défini. Une liste liée à la base explicite ou virtuelle d'un destructeur implicitement défini n'a pas pu être détruite. Le destructeur implicitement spécifié est virtuel, et la méthode de réallocation renvoie une procédure non définie, terminée ou isolée. Lorsqu'un compilateur localise un destructeur implicitement défini qui n'est pas supprimé, il est spécifié implicitement. Le corps de ce destructeur implicitement déclaré est vide.

#inclure
Utilisation de Namespace Std;
lien de structure

int d;
lien * suivant;
;
Class LinkList

privé:
lien * d'abord;
public:
linkList ()
premier = null;
~ linkList ();
void addval (int a);
void disposer ();
;
void linklist :: addval (int a)

lien * newLink = new link;
newLink-> d = a;
newLink-> next = premier;
d'abord = newLink;

void linklist :: display ()

Au début du programme, nous inclurons un fichier d'en-tête . Parallèlement à cela, l'espace de noms standard est également utilisé. Nous déclarons un membre de la liste nommée «lien». La variable «D» pour le stockage de l'ensemble de données est en cours d'initialisation. Nous créons un pointeur pour la liste suivante. Ici, nous construisons la classe appelée 'linklist'. C'est une liste de liens. Son pointeur vers le premier lien est défini en tant que privé, et le constructeur est défini publiquement.

Le constructeur de la «liste de liaison» n'a pas de paramètre. Nous avons fourni le «premier» lien vers la valeur «null». Ensuite, nous avons utilisé le destructeur '~ linkList ()'. En C ++, un destructeur est une méthode qui supprime un élément. Il n'a pas de paramètres d'entrée et pas de type de sortie. Nous ajouterons les éléments à la liste des liens. Nous appliquons donc la fonction void addval (). Cette fonction contient l'ensemble de données requise comme argument.

Nous avons utilisé la fonction void affichage () pour afficher tous les liens. Ici, nous créons un nouveau lien. Nous fournissons l'ensemble de données sur le nouveau lien en utilisant l'opérateur (>). Cet opérateur pointe vers le lien suivant. Le premier élément de la première liste de liens est indiqué le nouveau lien. Nous devons afficher la liste liée spécifiée à l'aide de la fonction d'affichage ().

lien * current = premier;
pendant que (actuel != Null)

couter<Current = Current-> Suivant;


linklist :: ~ linkList ()

lien * current = premier;
pendant que (actuel != Null)

lien * temp = courant;
Current = Current-> Suivant;
supprimer la température;


int main()

linkList l;
l.addval (11);
l.addval (22);
l.addval (33);
l.addval (44);
l.afficher();
couter<retour 0;

En plus de cela, nous avons défini le pointeur «* actuel» sur le premier lien. Nous appliquons la boucle while ici. Le destructeur est appliqué sur la «liste de liaison». De même, nous avons à nouveau réglé le pointeur sur le premier élément du lien et nous arrêtons sur le dernier élément du lien en utilisant la boucle 'while'. Nous initialisons une nouvelle variable, «Temp», pour stocker le pointeur du premier lien. L'opérateur (->) est utilisé pour acquérir le pointeur vers le nouveau lien.

Par conséquent, nous supprimons la variable «temporaire». Le corps de la fonction principale () est en cours. Les données de cette liste liée sont stockées dans une variable «L». Maintenant, nous insérons séparément quatre valeurs aléatoires dans la liste à l'aide du L.Fonction addVal (). Nous utilisons le L.Méthode afficher () pour afficher l'intégralité de la liste liée. Avant d'entrer dans la commande 'return o', nous ajoutons 'endl'. Il imprime simplement les valeurs de la liste liée dans des lignes distinctes.

Utilisation du destructeur trivial

Le destructeur trivial n'est pas abordé directement. Ils seront soit déclarés automatiquement ou déclarés explicitement. Ce destructeur n'est pas dynamique; Par conséquent, le destructeur de la classe parent n'est pas dynamique. Les destructeurs sont triviaux dans toutes les classes abstraites primaires. Les destructeurs sont triviaux pour certains objets de données non statiques ou tableaux de la sous-classe. Les destructeurs sont souvent inversement inversement que les constructeurs sont. Des éléments ayant des destructeurs triviaux n'auraient pas besoin d'une dépression pour être rejetée; ils peuvent plutôt être réaffectés.

#inclure
Utilisation de Namespace Std;
classe voyage
public:
Voyage()

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

couter<< "Destructor Invoked for Travel class" <
;
CLASSE CAR
public:
Voiture()

couter<< "Constructor Invoked for Car class" <
~ Car ()

couter<< "Destructor Invoked for Car class" <
;
int Main (vide)

Voyager T1;
Voiture C2;
retour 0;

Tout d'abord, nous intégrons le fichier d'en-tête et l'espace de noms standard. Nous déclarons une liste liée en tant que «voyage» de classe. Nous définissons publiquement le constructeur de cette classe. Nous avons utilisé la commande «cout» pour imprimer le texte. Ensuite, le destructeur '~ Travel ()' de la classe est également construit. Pour afficher la ligne, nous entrons à nouveau la déclaration «cout». Nous avons créé une deuxième classe du programme nommé «voiture».

De la même manière, nous définissons le constructeur et le destructeur de cette classe. La fonction principale () est appelée. L'objet «t1» de la classe «voyage» et objet «C2» de la classe «voiture» a été créé dans le corps de la fonction principale (). Nous devons saisir la commande «return 0» pour résilier le programme.

Le constructeur d'un objet appelé «T1» est instantanément invoqué avant de construire l'objet dans la première section de la fonction principale (). Ainsi, chaque fois que l'objet «C2» de la classe «voiture» est fabriqué dans la deuxième ligne de fonction main (), le compilateur appelle implicitement le constructeur lié à l'objet «C2».

Les destructeurs sont souvent invoqués dans la séquence opposée en tant que constructeurs. Une fois que le contexte de la fonction principale () se termine, le destructeur associé à l'objet «C2» est appelé d'abord. Par la suite, le destructeur associé à l'objet «T1» est invoqué.

Conclusion

Dans cet article, nous avons discuté du destructeur des listes liées en C++. Les destructeurs ne seront jamais explicitement invoqués. Les destructeurs n'ont pas de déclaration de retour. Nous pouvons implémenter un destructeur pour révéler le stockage juste avant la suppression de la liste liée lorsqu'une liste comprend un pointeur vers la mémoire du système. Pour minimiser les débordements de tampon, cela peut être effectué.