Lista enlazada usando plantillas en C++
- Lista enlazada usando plantillas en C++
-
Cree la lista vinculada utilizando la plantilla del archivo
.cpp - Conclusión
Una plantilla es un tipo de datos definido por clase creado cuando el tipo de datos a utilizar está en duda. El uso de una plantilla brinda la capacidad de ser flexible con los tipos de datos y usar solo ese tipo de datos proporcionado como entrada durante el tiempo de compilación.
Este artículo explica cómo podemos formar una lista enlazada usando una plantilla en C++.
Lista enlazada usando plantillas en C++
Este artículo presenta un programa de 3 partes que contiene el archivo principal (archivo .cpp) que extrae el nodo y los datos de la lista enlazada de sus archivos de encabezado (.h). El programa proporciona información a través del archivo principal que contiene el método del controlador.
Primero, comprendamos cómo crear nodos usando plantillas.
Inicializar miembros de datos dentro de la clase de plantilla en C++
Este es el primer archivo de encabezado que inicia el programa durante la compilación. Aquí se definen dos clases: create_list e 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 sintaxis template<typename T> class create_list; crea una clase de tipo T. Esto le dice al compilador que use T como un tipo de datos definido por el usuario hasta que se proporcione un tipo de datos primario.
El uso de plantillas en un programa C++ proporciona una función interesante para definir una variable utilizando un tipo de datos definido por el usuario. Del mismo modo, los métodos también se pueden definir como tipo de datos, lo que los convierte en una herramienta útil para los programadores.
Usando la sintaxis friend class create_list<T>; indica al compilador que etiquete la clase create_list como clase amiga. Una clase amiga comparte sus miembros públicos y privados en este archivo de encabezado.
Una vez definida la clase create_list, se crea la clase Init con tipo T.
Cuando el compilador ejecuta la sintaxis friend class create_list<T>;, indica al compilador que use los miembros privados y públicos del archivo de encabezado create_list.h en esta clase.
Se requieren dos variables principales para crear una lista vinculada usando plantillas en C++, una variable de datos que almacena el valor de entrada y una variable de nodo que apunta al siguiente puntero.
En este programa, estas dos variables principales se definen como data y siguiente. Luego, los miembros privados y públicos de los constructores se inicializan utilizando valores predeterminados antes de que se realicen operaciones en ellos.
Por último, las variables miembro del constructor público se inicializan con las variables miembro del constructor privado.
Crear una lista vinculada de clases usando una plantilla en C++
Esta sección analiza la segunda parte de las tres partes de este artículo. El programa discutido aquí importa el archivo de encabezado init.h usando la sintaxis #include "init.h" y usa sus miembros de datos para crear la Lista Vinculada usando la plantilla en C++.
Dentro de la clase de plantilla create_list, hay cuatro miembros públicos: un constructor create_list(), un destructor ~create_list() y dos métodos de miembro void insert() y void display().
Se definen dos miembros privados, punteros *up y *down, con tipo de datos T. Este tipo de datos definido por clase permite que el programa use cualquier tipo de datos en el programa controlador, evitando así que el programador vuelva al código fuente para modificar cosas.
Las variables de puntero cabeza y cola se inicializan dentro del constructor create_list.
template <typename T>
create_list<T>::create_list() : up(0), down(0)
Dentro del destructor ~create_list(), se liberan los objetos almacenados dentro de la memoria.
Aquí, si el objeto up tiene algún valor almacenado dentro, se copia dentro del puntero *a; al puntero *b se le da un valor 0.
Las variables de puntero cabeza y cola se inicializan dentro del constructor create_list.
template <typename T>
create_list<T>::~create_list() {
if (up) {
Init<T> *a = up;
Init<T> *b = 0;
Por la cantidad de veces que a tiene valores, se copia en b, que actúa como un marcador de posición para los objetos dentro de la variable a. Luego, a a se le da el valor almacenado dentro del siguiente puntero, y al final, se liberan los valores dentro de b.
while (a) {
b = a;
a = a->next;
delete b;
}
Método para agregar valores dentro de la lista vinculada
Esta parte del programa crea un método con clase tipo T que toma información como parámetro. Dentro del método, se da una condición if-else.
La variable down se utiliza para apuntar al siguiente puntero. Aquí, la condición if comprueba que si la variable up no está vacía, crea un nuevo objeto a partir de la información del parámetro y lo transfiere a la variable abajo.
Dentro de la condición else, la variable up recibe el valor de down, que es el objeto creado a partir del parámetro 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étodo para imprimir los valores dentro de la lista vinculada
Este método imprime el contenido de la lista enlazada. El valor del puntero dentro de la variable up se copia en una variable *a.
Para el número de veces que los valores están allí en el puntero dado a, el bucle while lo imprime y luego cambia a al puntero up.
template <typename T>
void create_list<T>::display() {
if (up) {
Init<T> *a = up;
while (a) {
cout << a->data << "->";
a = a->next;
}
La siguiente sección muestra el código para crear una lista enlazada utilizando plantillas de 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;
}
}
Cree la lista vinculada utilizando la plantilla del archivo .cpp
Esta es la parte final del programa. Incluye el archivo de encabezado create_list, y se crea la función principal.
El tipo de datos de la plantilla de lista enlazada se establece dentro de la función principal. Aquí, char se usa para imprimir los valores ASCII de los números dentro del bucle for dado.
El bucle for se ejecuta diez veces e imprime los valores ASCII del 65 al 75, letras de la A a la J. El list.insert(i); La sintaxis pasa el valor de i al método add, que se inserta en la lista enlazada, y luego se pasa otro valor.
Finalmente, list.display(); imprime el contenido de la lista enlazada.
// 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();
Conclusión
Este artículo proporciona una explicación detallada de cómo se crean las listas vinculadas mediante plantillas en C++. Después de leer el artículo, el lector podrá crear programas con tipos de datos definidos por el usuario y usar listas vinculadas con múltiples tipos de datos a la vez.