Liste liée à l'aide de modèles en C++
- Liste liée à l’aide de modèles en C++
-
Créer la liste liée à l’aide du modèle à partir du fichier
.cpp - Conclusion
Un modèle est un type de données défini par la classe créé lorsque le type de données à utiliser est en question. L’utilisation d’un modèle donne la possibilité d’être flexible avec les types de données et d’utiliser uniquement le type de données fourni en entrée lors de la compilation.
Cet article explique comment nous pouvons former une liste liée à l’aide d’un modèle en C++.
Liste liée à l’aide de modèles en C++
Cet article présente un programme en 3 parties contenant le fichier principal (fichier .cpp) qui extrait les données des nœuds et des listes chaînées de ses fichiers d’en-tête (.h). Le programme fournit une entrée via le fichier principal contenant la méthode du pilote.
Voyons d’abord comment créer des nœuds à l’aide de modèles.
Initialiser les membres de données à l’intérieur de la classe de modèle en C++
Il s’agit du premier fichier d’en-tête que le programme initie lors de la compilation. Ici deux classes sont définies : create_list et Init.
// file: init.h
#ifndef _INIT_H
#define _INIT_H
template <typename T>
class create_list;
template <typename T>
class Init {
friend class create_list<T>;
public:
Init(T data = 0, Init<T> *next = 0) : data(data), next(next) { /* empty */
}
private:
T data;
Init<T> *next;
};
#endif
La syntaxe template<typename T> class create_list; crée une classe de type T. Cela indique au compilateur d’utiliser T comme type de données défini par l’utilisateur jusqu’à ce qu’un type de données principal soit donné.
L’utilisation de modèles dans un programme C++ fournit une fonctionnalité intéressante pour définir une variable à l’aide d’un type de données défini par l’utilisateur. De même, les méthodes peuvent également être définies comme des types de données, ce qui en fait un outil utile pour les programmeurs.
Utilisation de la syntaxe friend class create_list<T>; ordonne au compilateur de marquer la classe create_list en tant que classe amie. Une classe amie obtient ses membres privés et publics partagés dans ce fichier d’en-tête.
Une fois la classe create_list définie, la classe Init est créée avec le type T.
Lorsque le compilateur exécute la syntaxe friend class create_list<T>;, il ordonne au compilateur d’utiliser les membres privé et public du fichier d’en-tête create_list.h dans cette classe.
Deux variables principales sont nécessaires pour créer une liste chaînée à l’aide de modèles en C++, une variable de données qui stocke la valeur d’entrée et une variable de nœud qui pointe vers le pointeur suivant.
Dans ce programme, ces deux variables principales sont définies comme data et next. Ensuite, les membres privés et publics des constructeurs sont initialisés à l’aide de valeurs par défaut avant que des opérations ne soient effectuées sur eux.
Enfin, les variables membres du constructeur public sont initialisées avec les variables membres du constructeur private.
Créer une liste liée de classe à l’aide d’un modèle en C++
Cette section traite de la deuxième partie des trois parties de cet article. Le programme décrit ici importe le fichier d’en-tête init.h en utilisant la syntaxe #include "init.h" et utilise ses données membres pour créer la liste chaînée à l’aide du modèle en C++.
À l’intérieur de la classe de modèle create_list, il y a quatre membres publics - un constructeur create_list(), un destructeur ~create_list(), et deux méthodes membres void insert() et void display().
Deux membres privés sont définis, les pointeurs *up et *down, avec le type de données T. Ce type de données défini par la classe permet au programme d’utiliser n’importe quel type de données dans le programme pilote, évitant ainsi au programmeur de revenir au code source pour modifier les choses.
Les variables de pointeur head et tail sont initialisées à l’intérieur du constructeur create_list.
template <typename T>
create_list<T>::create_list() : up(0), down(0)
A l’intérieur du destructeur ~create_list(), les objets stockés en mémoire sont libérés.
Ici, si l’objet up a une valeur stockée à l’intérieur, il est copié à l’intérieur du pointeur *a ; le pointeur *b prend la valeur 0.
Les variables de pointeur head et tail sont initialisées à l’intérieur du constructeur create_list.
template <typename T>
create_list<T>::~create_list() {
if (up) {
Init<T> *a = up;
Init<T> *b = 0;
Pour le nombre de fois où a a des valeurs, il est copié dans b, qui agit comme un espace réservé pour les objets à l’intérieur de la variable a. Ensuite, a reçoit la valeur stockée à l’intérieur du pointeur suivant, et à la fin, les valeurs à l’intérieur de b sont libérées.
while (a) {
b = a;
a = a->next;
delete b;
}
Méthode pour ajouter des valeurs à l’intérieur de la liste liée
Cette partie du programme crée une méthode avec le type de classe T qui prend info en paramètre. A l’intérieur de la méthode, une condition if-else est donnée.
La variable down est utilisée pour pointer vers le pointeur suivant. Ici, la condition if vérifie que si la variable up n’est pas vide, elle crée un nouvel objet à partir du paramètre info et le transfère à la variable down.
A l’intérieur de la condition else, la variable up reçoit la valeur de down, qui est l’objet créé à partir du paramètre value.
template <typename T>
void create_list<T>::insert(T value) {
if (up) {
down->next = new Init<T>(value);
down = down->next;
} else {
up = down = new Init<T>(value);
}
}
Méthode pour imprimer les valeurs à l’intérieur de la liste liée
Cette méthode imprime le contenu de la liste liée. La valeur du pointeur à l’intérieur de la variable up est copiée dans une variable *a.
Pour le nombre de fois où les valeurs sont là dans le pointeur donné a, la boucle while l’imprime puis décale a vers le pointeur up.
template <typename T>
void create_list<T>::display() {
if (up) {
Init<T> *a = up;
while (a) {
cout << a->data << "->";
a = a->next;
}
La section ci-dessous montre le code pour créer une liste liée à l’aide de modèles C++ :
// file createlist.h
#ifndef _CREATELIST_H
#define _CREATELIST_H
#include <iostream>
using namespace std;
#include "init.h"
template <typename T>
class create_list {
public:
create_list();
~create_list();
void insert(T);
void display();
private:
Init<T> *up;
Init<T> *down;
};
#endif
template <typename T>
create_list<T>::create_list() : up(0), down(0) { /* empty */
}
template <typename T>
create_list<T>::~create_list() {
if (up) {
Init<T> *a = up;
Init<T> *b = 0;
while (a) {
b = a;
a = a->next;
delete b;
}
cout << endl;
}
}
template <typename T>
void create_list<T>::insert(T value) {
if (up) {
down->next = new Init<T>(value);
down = down->next;
} else {
up = down = new Init<T>(value);
}
}
template <typename T>
void create_list<T>::display() {
if (up) {
Init<T> *a = up;
while (a) {
cout << a->data << "->";
a = a->next;
}
cout << endl;
}
}
Créer la liste liée à l’aide du modèle à partir du fichier .cpp
C’est la dernière partie du programme. Il inclut le fichier d’en-tête create_list et la fonction principale est créée.
Le type de données du modèle de liste liée est défini dans la fonction principale. Ici, char est utilisé pour imprimer les valeurs ASCII des nombres à l’intérieur de la boucle for donnée.
La boucle for s’exécute dix fois et imprime les valeurs ASCII de 65 à 75, lettres A à J. La list.insert(i); La syntaxe passe la valeur de i à la méthode add, qui est insérée dans la liste chaînée, puis une autre valeur est passée.
Enfin, list.display(); imprime le contenu de la liste chaînée.
// file run.cpp
#include "create_list.h"
int main(int argc, char *argv[]) {
create_list<char> created_list;
for (char i = 65; i < 75; i++) created_list.insert(i);
created_list.display();
Conclusion
Cet article fournit une explication détaillée de la façon dont les listes liées sont créées à l’aide de modèles en C++. Après avoir parcouru l’article, le lecteur pourra créer des programmes avec des types de données définis par l’utilisateur et utiliser des listes liées avec plusieurs types de données à la fois.