Wie verwende ich eine einzelne Template-Anweisung für mehr als eine Funktion oder Struktur?

Question

Ich habe versucht, Stacks als Vorlage darzustellen, ich benutzte eine Struktur und alles ist gut, aber jedes Mal, wenn ich eine Template-Funktion schreiben wollte, musste ich die gleiche Template-Anweisung schreiben, die nicht korrekt zu sein schien -Obwohl Arbeiter

So wie kann ich ein Template-Anweisung für alle Funktionen schreiben ?, hier ist mein Code:

 
template <typename T> 
struct Stack 
{ 
    T Value; 
    Stack* next; 
}; 
template <typename T> 
void Push(T Value,Stack* &Top) 
{ 
    Stack * Cell = new Stack(); 
    Cell->Value = Value; 
    Cell->next = Top; 
    Top = Cell; 
}; 
template <typename T> 
bool IsEmpty(Stack * Top) 
{ 
    return (Top==0); 
} 
template <typename T> 
void Pop(T &Value,Stack* &Top) 
{ 
    if (IsEmpty(Top)) 
     cout * Temp = Top; 
     Value = Top->Value; 
     Top = Top->next; 
     delete Temp; 
    } 
} 
template <typename T> 
void GetTop(T &Value, Stack* &Top) 
{ 
    if (IsEmpty(Top)) 
     cout Value; 
} 
template <typename T> 
void EmptyStack(Stack * &Top) 
{ 
    Stack * Temp; 
    while (!(IsEmpty(Top))) 
    { 
     Temp = Top; 
     Top = Top->next; 
     delete Temp; 
    } 
} 

Hoffnung, was ich meine klar ist jetzt, sorry für die leichte Frage :(

danke im voraus

Answer 1

Wenn (wie es scheint, basierend auf Ihrem Kommentar) Sie sie als freie Funktionen möchten, können Sie nicht. Sie werden auch die Stack Parameter ändern müssen, so etwas wie dieses:

template <typename T> 
void Push(T Value, Stack<T>* &Top) 
{ 
    Stack * Cell = new Stack(); 
    Cell->Value = Value; 
    Cell->next = Top; 
    Top = Cell; 
}; 

Wie es aussieht, ich bin aber nicht allzu begeistert über Ihr Design. Sie versuchen, den Stack Typ als einen tatsächlichen Stapel, und als einen einzigen Knoten (Cell) in den Stapel zu verwenden. Dies ist im besten Fall unnötig verwirrend.

Edit: Was Stapel vs. Knoten geht, was ich rede ist (wie im Code sofort oben): Stack *Cell = new Stack(); - Sie eine einzelne Zelle, die Zuweisung von in der Stapel geht, aber der Typ, den Sie dafür verwenden, ist istStack.

Ich würde so etwas tun, statt:

template <class T> 
struct Stack { 
    struct node { 
     T data; 
     node *next; 
    }; 

    node *head; 
}; 

template <class T> 
void push(T item, Stack<T> *&s) { 
    Stack<T>::node *n = new Stack<T>:node();  
    n->data = item; 
    n->next = s->head; 
    s->head = n; 
} 

Es ist nicht viel Unterschied machen, was Sie wirklich tun, aber wenn man etwas auf einen Stapel setzen ist, Aufteilung eines Stack<T>::node scheint (zumindest für mich) viel sinnvoller zu sein als eine Stack<T> zuzuweisen. Ein Stack mit mehreren Knoten ist sinnvoll - ein Stack mit mehreren Stacks tut dies nicht.

Answer 2

Sie könnten einfach eine Vorlagenklasse schreiben und all diese Funktionen als Methoden dieser Klasse schreiben. Sie teilen dann die gleichen Template-Parameter wie die Klasse.