Schwierigkeit mit Template-Klasse

Question

Okay, Leute, ich habe versucht, einen Stack zu definieren, jeder Knoten ist auch von Template-Typ, aber ich bekomme Dutzende verschiedene Arten von Fehlern, wenn das Prog versucht zu kompilieren. Ich werde das Programm einfügen, die einen char-Typ-Stapel verwendet und versucht, Buchstaben 'e'

#ifndef STACK_LIST_H 
#define STACK_LIST_H 
#include "List.h" 

using namespace std; 
template <class T> 
class Stack { 
public: 
    T pop(); 
    void push(T x); 
    T isEmpty(); 
    T top(); 

private: 
    int  size; 
    Node<T> * headNode; 
    Node<T> * currentNode; 


}; 

#endif 

Nun wird die Funktionsdefinitionen Pop:

#include <iostream> 
#include "Stack_list.h" 

using namespace std; 
template <class T> 
T Stack<T>::pop(){ 
    T x = headNode->get(); 
    Node<T>* p = new Node<T>::Node(); 
    p = headNode; 
    headNode = headNode->getNext(); 
    delete p; 
    return x; } 

template <class T> 
void Stack<T>::push(T x){ 
    Node<T>* newNode = new Node<T>::Node(); 
    newNode->setNext(headNode); 
    newNode->set(x); 
    headNode=newNode; 
} 

template <class T> 
int Stack<T>::isEmpty(){ 
return (headNode ==NULL);} 

template <class T> 
T Stack<T>::top(){ 
return headNode->get(); 
} 

jetzt der Template-Klasse Knoten:

#ifndef LIST_H 
#define LIST_H 

using namespace std; 

/* The Node class */ 
template <class T> 
class Node 
{ 
    public: 
     Node(T here){object=here;}; 
     T get() { return object; }; 
     void set(T object) { this->object = object; }; 
     Node<T>* getNext() { return nextNode; }; 
     void setNext(Node<T>* nextNode) { this->nextNode = nextNode; }; 
     Node<T>* getPrev(){ return prevNode;}; 
     void setPrev(Node<T>* prevNode){this->prevNode=prevNode;}; 
    private: 
     T object; 
     Node<T>* nextNode; 
     Node<T>* prevNode; 
}; 
#endif 

und schließlich das Programm, das die Klassen evoziert:

#include <iostream> 
#include "Stack_list.cpp" 
using namespace std; 

int main(){ 
Stack <char>s; 
s.push("e"); 
cout<<s.pop(); 
} 

Wie Sie sehen können, ist dies mein erster Versuch bei Template-Klassen. In Definitionen von Stapel :: pop() und Push (T) heißt es: "erwarteten Typ-Spezifizierer vor 'Knoten'"

Answer 1

Node<T>* newNode = new Node() ist inkonsistent. Ist Node eine Klasse oder eine Klassenvorlage? Wenn Sie es zum ersten Mal erwähnen, behandeln Sie es als Vorlage und instanziieren es mit T, aber das zweite Mal behandeln Sie es als eine Klasse. Es kann nicht beides sein.

Answer 2

Ihre Methodendefinition Signaturen sind:

T Stack<T>::pop() 

aber sie sollten

sein auch

template<typename T> 
T Stack<T>::pop() 

, da Stack verwendet Node, haben Sie Node.h in Stack.h aufzunehmen.

Weiterhin - in Stack haben Sie T isEmpty(); deklariert, aber als int Stack<T>::isEmpty() implementiert. Bleiben Sie bei einem Rückgabetyp (wahrscheinlich bool ist hier geeigneter, aber int ist auch OK).

Schließlich:

Stack <char>s; 
s.push("e"); 

Die Template-Spezialisierung ist char, aber "e" ist ein const char*. Der korrekte Weg wäre:

Stack <char>s; 
s.push('e'); // <- note the single quotes