Copier la liste liée au constructeur C ++

Un constructeur de copie est comme un constructeur; C'est une fonction qui est utilisée pour initialiser une valeur à un objet à l'aide d'un autre objet dans la même classe. Il est plus facile à utiliser dans le langage de programmation C ++ lorsqu'il y a plusieurs paramètres d'objet dans la classe. Cet article utilisera la fonction du constructeur de copie dans la liste liée.

Quand appelons-nous un constructeur de copie?

Dans le langage de programmation C ++, nous pouvons appeler une fonction de copie dans les situations suivantes. Il est appelé lorsque nous retournons un objet de la classe par la valeur. Un constructeur de copie est également recommandé d'être utilisé dans la condition lorsque nous passons un objet de la classe par une valeur en tant que paramètre lorsque nous créons un objet créé en fonction de l'autre objet appartenant à la même classe.

Types d'un constructeur de copie

Il existe deux types de constructeurs de copie.

Copier le constructeur (par défaut)

Si l'utilisateur ne définit aucun constructeur de copie, alors, dans ce cas, le compilateur fournit son constructeur.

Constructeur défini par l'utilisateur

Le programmeur définit toujours le constructeur défini par l'utilisateur.

Quand avons-nous besoin d'un constructeur de copie?

Si notre constructeur de copie n'est pas défini, le compilateur C ++ crée le constructeur de copie qui est le par défaut. Nous devons définir notre constructeur lorsqu'un objet utilise des pointeurs, une allocation de mémoire dynamique ou d'autres ressources.

Syntaxe

Name_of_class (const name_of_class & object_name)

// corps constructeur

Après avoir utilisé le constructeur de copie, nous obtenons deux copies. L'un est connu comme une copie peu profonde, tandis que la seconde est une copie profonde. La copie peu profonde est produite par le constructeur de copie par défaut. Alors que le constructeur de copie profonde alloue automatiquement la mémoire, il copie la valeur réelle. Les valeurs copiées et réelles sont stockées à différents endroits à l'intérieur de la mémoire. On dit qu'une copie profonde est requise lors de la création d'un constructeur défini par l'utilisateur.

Implémentation d'un constructeur de copie

Nous avons implémenté le code dans l'éditeur de texte d'Ubuntu, et la valeur résultante est obtenue par exécution sur le terminal Linux.

Ce programme utilisera le concept de programmation orienté objet, car les constructeurs sont utilisés pour faire des cours. Une classe est créée avec la partie privée ayant des valeurs de type entier. Dans la partie publique, un constructeur est créé avec le nom de la classe. Ce constructeur utilisera deux valeurs dans le paramètre pour recevoir la valeur transmise du programme principal. À l'intérieur du constructeur, les valeurs envoyées sont affectées aux nouvelles variables.

Après le constructeur, encore une fois, un nouveau constructeur est créé. C'est un constructeur copié. Comme nous l'avons décrit ci-dessus, ce constructeur prend le nom de classe et l'objet créé.

Ensuite, nous avons utilisé deux fonctions, getx () et get (), qui renvoie la valeur des variables. Dans le programme principal, les constructeurs sont appelés en utilisant le nom de classe, chacun (original), et le constructeur de copie contient des arguments dans le paramètre lors de l'appel. Le constructeur normal contient deux valeurs transmises à la variable. Et le constructeur de copie est affecté à l'objet de la première classe. Pour afficher la valeur résultante, nous appellerons la fonction Get en utilisant des objets des deux constructeurs.

Nous allons enregistrer le code et l'exécuter en utilisant le compilateur G++.

Lors de l'exécution du code source, vous pouvez voir que les deux valeurs sont les mêmes que les constructeurs sont passés de l'original ou par le constructeur de copie.

Concept de liste liée en C++

Une liste liée est une structure de données qui contient plusieurs nœuds connectés via les adresses stockées dans chaque nœud.

nœud de structure

données entières;
struct nœud * next_part;
;

Nous créons une structure ayant une partie de données qui stocke les valeurs et la partie suivante qui stocke l'adresse du nœud adjacent. La prochaine étape que nous faisons consiste à initialiser les nœuds du programme principal. Tous les nœuds sont déclarés nuls en utilisant les pointeurs.

Chaque partie de données du nœud est attribuée par les valeurs. Cela se fait en accédant à cette partie du nœud.

Un -> data = 1;

De même, tous les nœuds obtiennent leurs données pertinentes.

L'essentiel dans la liste liée est la connexion entre les nœuds créés. Cela se fait lorsque la partie suivante d'un nœud est attribuée avec l'adresse du deuxième nœud; De même, le deuxième nœud contient l'adresse du troisième. Et ainsi de suite, ce processus se poursuit jusqu'au dernier nœud. La prochaine partie du dernier nœud est déclarée nul car il n'y a plus de nœud ici.

Le constructeur de copie et la liste liée en C++

Pour utiliser un constructeur de copie dans la liste liée, nous avons utilisé une structure pour créer le nœud. Après la fermeture de la structure, une classe avec le nom Linked_List est utilisée ici. La partie privée contiendra les variables d'une tête de type pointeur et d'une queue. Un constructeur normal attribue les valeurs aux parties de la tête et de la queue dans la partie publique.

Deux variables de type entier accepteront les valeurs qui seront envoyées à partir du programme principal en créant l'objet. Ces variables sont affectées aux variables de tête et de queue pour y stocker des valeurs. Après le constructeur normal, un constructeur de copie est déclaré. Ce sera du même nom, et son paramètre contiendra un nom de classe constant avec l'objet. Ce constructeur est également attribué avec les mêmes valeurs. Mais ceux-ci sont accessibles avec les objets. Nous obtiendrons ces valeurs en utilisant la fonction get (). Les deux valeurs dans la variable seront retournées.

Après le constructeur, une fonction simple de l'ajout d'un nœud au nœud existant est utilisée. Un nouveau nœud de nom temporaire est créé. La partie de données est attribuée avec la valeur. Et la partie suivante est déclarée nul. Ici, nous vérifions si le nœud ajouté est le premier ou que la liste liée contient déjà un nœud. Donc, une instruction IF-ELSE est utilisée ici. Il vérifiera si la tête est égale à Null, puis la tête et la queue se sont attribuées la valeur de «TMP». Mais dans un autre cas, s'ils ne sont pas nuls, la partie suivante de la queue est attribuée à l'adresse d'un nouveau nœud. Cela signifie que «TMP» contiendra l'adresse de la queue. Et la queue obtiendra la valeur mise à jour.

Maintenant, dans le programme principal, nous allons créer l'objet de la classe; En créant l'objet, les constructeurs sont appelés. Le constructeur d'origine et de copie contiendra les valeurs des paramètres. Le constructeur de copie crée l'objet et est affecté avec l'objet du constructeur d'origine.

Ces valeurs seront affichées. Pour voir la valeur résultante, exécutez le programme sur le terminal. Vous pouvez voir que les deux constructeurs ont les mêmes valeurs.

Conclusion

Cet article explique le travail et la création d'un constructeur de copie dans la liste liée à l'aide de C++. Cela se fait en expliquant le constructeur de copie, ses types et l'utilisation dans un programme simple démontré dans l'exemple. De plus, le concept de création de liste liée est également expliqué. Un exemple combiné d'une liste liée au constructeur de copie est utilisé pour effacer chaque ambiguïté de l'utilisateur final.