Verkettete Liste mit Vorlagen in C++
- Verkettete Liste mit Vorlagen in C++
-
Erstellen Sie die verknüpfte Liste unter Verwendung einer Vorlage aus einer
.cpp-Datei - Fazit
Eine Vorlage ist ein klassendefinierter Datentyp, der erstellt wird, wenn der zu verwendende Datentyp fraglich ist. Die Verwendung einer Vorlage bietet die Möglichkeit, mit Datentypen flexibel zu sein und nur den Datentyp zu verwenden, der während der Kompilierzeit als Eingabe bereitgestellt wird.
In diesem Artikel wird erläutert, wie wir mithilfe einer Vorlage in C++ eine verknüpfte Liste erstellen können.
Verkettete Liste mit Vorlagen in C++
Dieser Artikel stellt ein dreiteiliges Programm vor, das die Hauptdatei (.cpp-Datei) enthält, die die Knoten- und Linked-List-Daten aus ihren Header-Dateien (.h) extrahiert. Das Programm liefert Eingaben über die Hauptdatei, die die Treibermethode enthält.
Lassen Sie uns zunächst verstehen, wie Knoten mithilfe von Vorlagen erstellt werden.
Initialisieren Sie Datenmember innerhalb der Vorlagenklasse in C++
Dies ist die erste Header-Datei, die das Programm während der Kompilierung initiiert. Hier sind zwei Klassen definiert: create_list und 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
Die Syntax template<typename T> class create_list; erstellt eine Klasse vom Typ T. Dies weist den Compiler an, T als benutzerdefinierten Datentyp zu verwenden, bis ein primärer Datentyp angegeben ist.
Die Verwendung von Vorlagen in einem C++-Programm bietet eine interessante Funktion, um eine Variable mit einem benutzerdefinierten Datentyp zu definieren. Ebenso können Methoden auch als Datentyp definiert werden, was sie zu einem nützlichen Werkzeug für Programmierer macht.
Verwenden Sie die Syntax friend class create_list<T>; weist den Compiler an, die Klasse create_list als Friend-Klasse zu markieren. Eine Freundesklasse erhält ihre privaten und öffentlichen Mitglieder, die in dieser Header-Datei geteilt werden.
Sobald die Klasse create_list definiert ist, wird die Klasse Init mit Typ T erstellt.
Wenn der Compiler die Syntax friend class create_list<T>; ausführt, weist er den Compiler an, die privaten und öffentlichen Elemente aus der Header-Datei create_list.h in dieser Klasse zu verwenden.
Zwei Hauptvariablen sind erforderlich, um eine verknüpfte Liste mithilfe von Vorlagen in C++ zu erstellen, eine Datenvariable, die den Eingabewert speichert, und eine Knotenvariable, die auf den nächsten Zeiger zeigt.
In diesem Programm sind diese beiden Hauptvariablen als data und next definiert. Dann werden die privaten und öffentlichen Member von Konstruktoren mit Standardwerten initialisiert, bevor Operationen an ihnen ausgeführt werden.
Zuletzt werden die Member-Variablen des Konstruktors public mit Member-Variablen des Konstruktors private initialisiert.
Erstellen Sie eine mit Klassen verknüpfte Liste mithilfe einer Vorlage in C++
In diesem Abschnitt wird der zweite Teil der drei Teile dieses Artikels behandelt. Das hier besprochene Programm importiert die Header-Datei init.h mit der Syntax #include "init.h" und verwendet ihre Datenelemente, um die Linked List mit der Vorlage in C++ zu erstellen.
Innerhalb der Template-Klasse create_list gibt es vier öffentliche Member – einen Konstruktor create_list(), einen Destruktor ~create_list() und zwei Member-Methoden void insert() und void display().
Zwei private Member sind definiert, Zeiger *up und *down, mit Datentyp T. Dieser klassendefinierte Datentyp erlaubt dem Programm, jeden Datentyp im Treiberprogramm zu verwenden, und erspart so dem Programmierer, zum Quellcode zurückzukehren Dinge ändern.
Pointer-Variablen head und tail werden innerhalb des Konstruktors create_list initialisiert.
template <typename T>
create_list<T>::create_list() : up(0), down(0)
Innerhalb des Destruktors ~create_list() werden die im Speicher abgelegten Objekte freigegeben.
Wenn hier im Objekt up ein Wert gespeichert ist, wird dieser in den Zeiger *a kopiert; Pointer *b erhält den Wert 0.
Pointer-Variablen head und tail werden innerhalb des Konstruktors create_list initialisiert.
template <typename T>
create_list<T>::~create_list() {
if (up) {
Init<T> *a = up;
Init<T> *b = 0;
Für die Häufigkeit, mit der a Werte hat, wird es in b kopiert, das als Platzhalter für Objekte innerhalb der Variablen a fungiert. Dann erhält a den Wert, der im nächsten Zeiger gespeichert ist, und am Ende werden die Werte in b freigegeben.
while (a) {
b = a;
a = a->next;
delete b;
}
Methode zum Hinzufügen von Werten innerhalb einer verknüpften Liste
Dieser Programmteil erstellt eine Methode vom Klassentyp T, die info als Parameter entgegennimmt. Innerhalb der Methode wird eine if-else-Bedingung angegeben.
Die down-Variable wird verwendet, um auf den nächsten Zeiger zu zeigen. Hier prüft die if-Bedingung, dass wenn die Variable up nicht leer ist, sie ein neues Objekt aus Parameterinfo erstellt und an die Variable down übergibt.
Innerhalb der else-Bedingung erhält die Variable up den Wert von down, dem Objekt, das aus dem Parameter value erstellt wird.
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);
}
}
Methode zum Drucken der Werte in der verknüpften Liste
Diese Methode gibt den Inhalt der verknüpften Liste aus. Der Zeigerwert innerhalb der Variablen up wird in eine Variable *a kopiert.
Für die Anzahl der Werte, die in dem angegebenen Zeiger a vorhanden sind, gibt die While-Schleife sie aus und verschiebt dann a auf den up-Zeiger.
template <typename T>
void create_list<T>::display() {
if (up) {
Init<T> *a = up;
while (a) {
cout << a->data << "->";
a = a->next;
}
Der folgende Abschnitt zeigt den Code zum Erstellen einer verknüpften Liste mit C++-Vorlagen:
// 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;
}
}
Erstellen Sie die verknüpfte Liste unter Verwendung einer Vorlage aus einer .cpp-Datei
Dies ist der letzte Teil des Programms. Es enthält die Header-Datei create_list, und die Hauptfunktion wird erstellt.
Der Datentyp der verknüpften Listenvorlage wird innerhalb der Hauptfunktion festgelegt. Hier wird char verwendet, um die ASCII-Werte der Zahlen innerhalb der gegebenen for-Schleife zu drucken.
Die for-Schleife läuft zehnmal und gibt die ASCII-Werte von 65 bis 75 aus, die Buchstaben A bis J. Die list.insert(i); Syntax übergibt den Wert von i an die Methode add, die in die verknüpfte Liste eingefügt wird, und dann wird ein weiterer Wert übergeben.
Zum Schluss list.display(); druckt den Inhalt der verknüpften Liste.
// 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();
Fazit
Dieser Artikel enthält eine detaillierte Erläuterung, wie verknüpfte Listen mithilfe von Vorlagen in C++ erstellt werden. Nach dem Lesen des Artikels ist der Leser in der Lage, Programme mit benutzerdefinierten Datentypen zu erstellen und verknüpfte Listen mit mehreren Datentypen gleichzeitig zu verwenden.