C++-Vorlagen - LinkedList

Question

EDIT -- Unten geantwortet, die abgewinkelten Klammern übersehen. Vielen Dank an alle.

Ich habe versucht, eine rudimentäre, einfach verknüpfte Liste zu schreiben, die ich in anderen Programmen verwenden kann. Ich möchte, dass sie mit eingebauten und benutzerdefinierten Typen arbeiten kann, was bedeutet, dass sie eine Vorlage sein muss.

Aus diesem Grund muss mein Knoten auch eine Vorlage sein, da ich die Informationen, die er speichern soll, nicht kenne. Ich habe eine Knotenklasse wie folgt geschrieben -

template <class T> class Node
{
    T data; //the object information
    Node* next; //pointer to the next node element

public:
    //Methods omitted for brevity
};

Meine verknüpfte Liste Klasse ist in einer separaten Klasse implementiert, und muss einen Knoten instanziieren, wenn neue Knoten am Ende der Liste hinzufügen. Ich habe dies wie folgt implementiert -

#include <iostream>
#include "Node.h"
using namespace std;

template <class T> class CustomLinkedList
{
    Node<T> *head, *tail;

public:

    CustomLinkedList()
    {
        head = NULL;
        tail = NULL;
    }

    ~CustomLinkedList()
    {

    }

    //Method adds info to the end of the list
    void add(T info)
    {
        if(head == NULL) //if our list is currently empty
        {
            head = new Node<T>; //Create new node of type T
            head->setData(info);
            tail = head;
        }
        else //if not empty add to the end and move the tail
        {
            Node* temp = new Node<T>;
            temp->setData(info);
            temp->setNextNull();
            tail->setNext(temp);
            tail = tail->getNext();
        }
    }

    //print method omitted
};

Ich habe eine Treiber-/Testklasse wie folgt eingerichtet -

#include "CustomLinkedList.h"
using namespace std;

int main()
{
    CustomLinkedList<int> firstList;

    firstList.add(32);
    firstList.printlist();
    //Pause the program until input is received
    int i;
    cin >> i;

    return 0;
}

Ich erhalte jedoch einen Fehler beim Kompilieren - Fehler C2955: 'Node': Verwendung einer Klassenvorlage erfordert Vorlagenargumentliste - die mich auf die folgende Codezeile in meiner add-Methode verweist -

Node* temp = new Node<T>;

Ich verstehe nicht, warum dies keine Informationen über den Typ hat, da es an die verknüpfte Liste übergeben wurde, wenn in meiner Treiberklasse erstellt. Was sollte ich tun, um die Typinformationen an Node zu übergeben?

Sollte ich eine private Knotenstruktur anstelle einer separaten Klasse erstellen und die Methoden beider Klassen in einer Datei kombinieren? Ich bin nicht sicher, ob dies das Problem lösen würde, aber ich denke, es könnte. Ich würde aber lieber getrennte Klassen haben, wenn möglich.

Danke, Andrew.

Answer 1

Außerdem müssen Sie den Template-Parameter für den Node *temp in printlist angeben.

Answer 2

// file: main.cc

#include "linkedlist.h"

int main(int argc, char *argv[]) {
    LinkedList<int> list;
    for(int i = 1; i < 10; i++) list.add(i);
    list.print();
}

// file: node.h

#ifndef _NODE_H
#define _NODE_H

template<typename T> class LinkedList;
template<typename T>class Node {
    friend class LinkedList<T>;
    public:
        Node(T data = 0, Node<T> *next = 0)
            : data(data), next(next)
        { /* vacio */ }
    private:
        T data;
        Node<T> *next;
};

#endif//_NODE_H

// file: linkedlist.h

#ifndef _LINKEDLIST_H
#define _LINKEDLIST_H

#include <iostream>
using namespace std;

#include "node.h"

template<typename T> class LinkedList {
    public:
        LinkedList();
        ~LinkedList();
        void add(T);
        void print();
    private:
        Node<T> *head;
        Node<T> *tail;
};

#endif//_LINKEDLIST_H

template<typename T>LinkedList<T>::LinkedList()
    : head(0), tail(0)
{ /* empty */ }

template<typename T>LinkedList<T>::~LinkedList() {
    if(head) {
        Node<T> *p = head;
        Node<T> *q = 0;

        while(p) {
            q = p;
            p = p->next;
            delete q;
        }

        cout << endl;
    }
}

template<typename T>LinkedList<T>::void add(T info) {
    if(head) {
        tail->next = new Node<T>(info);
        tail = tail->next;
    } else {
        head = tail = new Node<T>(info);
    }
}

template<typename T>LinkedList<T>::void print() {
    if(head) {
        Node<T> *p = head;

        while(p) {
            cout << p->data << "-> ";
            p = p->next;
        }

        cout << endl;
    }
}

Answer 3

Sie sollten neue Knoten folgendermaßen hinzufügen

Node<T>* temp=new node<T>;

Ich hoffe, Sie haben das Problem gelöst :)

Answer 4

#include<iostream>
using namespace std;

template < class data > class node {
    private :
        data t;
        node<data > *ptr;
    public:
    node() {
        ptr = NULL;
    }
    data get_data() {
        return t;
    }
    void set_data(data d) {
        t = d;
    }
    void set_ptr(node<data > *p) {
        ptr = p;
    }
    node * get_ptr() {
        return ptr;
    }
};
template <class data > node < data > * add_at_last(data  d  , node<data > *start) {
    node< data > *temp , *p  = start;
    temp = new node<data>();
    temp->set_data(d);
    temp->set_ptr(NULL);
    if(!start) {
        start = temp;
        return temp;
    }
    else {
        while(p->get_ptr()) {
            p = p->get_ptr();
        }
        p->set_ptr(temp);
    }
}
template < class data > void display(node< data > *start) {
    node< data > *temp;
    temp = start;
    while(temp != NULL) {
        cout<<temp->get_data()<<" ";
        temp = temp->get_ptr();
    }
    cout<<endl;
}
template <class data > node < data > * reverse_list(node<data > * start) {
    node< data > *p = start , *q = NULL , *r = NULL;
    while(p->get_ptr()) {
        q = p;
        p = p->get_ptr();
        q->set_ptr(r);
        r = q;
    }
    p->set_ptr(r);
    return p;
}
int main() {
    node < int > *start;
    for(int i =0 ; i < 10 ; i ++) {
        if(!i) {
            start = add_at_last(i , start);
        }
        else {
            add_at_last(i , start);
        }
    }
    display(start);
    start = reverse_list(start);
    cout<<endl<<"reverse list is"<<endl<<endl;
    display(start);
}