How to use a single Template statement for more than one function or struct?

Question

I've been trying to represent Stacks as a template, I used a struct and every thing is good, but every time I wanted to write a template function, I had to write the same template statement, which didn't seem correct -although working-

So how can I write one template statement for all the functions?, here is my 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;
    }
}

Hope what I mean is clear now, sorry for the slight question :(

thanks in advance.

Answer 1

If (as appears to be the case based on your comment) you want them as free functions, you can't. You'll also have to change the Stack parameter, something like this:

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

As it stands, I'm not too excited about your design though. You try to use the Stack type as both an actual stack, and as a single node (Cell) in the stack. This is unnecessarily confusing at best.

Edit: As far as stack vs. node goes, what I'm talking about is (as in the code immediately above): Stack *Cell = new Stack(); -- you're allocating a single Cell that goes in the stack, but the type you're using for it is Stack.

I'd do something like this instead:

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;
}

It doesn't make a lot of difference in what you're really doing, but when you're putting something onto a stack, allocating a Stack<T>::node seems (at least to me) to make a lot more sense than allocating a Stack<T>. A stack containing multiple nodes makes sense -- a Stack containing multiple stacks really doesn't.

Answer 2

You could simply write a template class instead, and write all those functions as methods of that class. They will then share the same template parameters as the class.