Описать класс, реализующий стек

#pragma once
 
#define NULL 0
 
template <class T>
class Stack                     // Stapel für Records vom beliebigen Typ item_type
{
    struct node                 // Einzeln Element von Stack        
    {
        T item;
        node* next;
    };
 
private:
    node* tail;                 // Letztes Element im Stack
    int anz_intems;             // Anzahl Elementen
 
public:
 
 
// leerer Stapel 
Stack(void) : anz_intems(0)
{
    tail=NULL;
}
 
//Destruktor
virtual ~Stack(void)
{
}
 
// legt Record r oben auf Stapel
template <class T> bool push(T &r)
{
     node* topNode = new node;
 
     if(!topNode) return 0;
    
     topNode->item = r;
     topNode->next = tail;
     tail = topNode;
 
     return 1;
}
 
// holt obersten Record vom Stapel
template <class T> void pop()
{
    if(!tail) 
    {
        std::cout << "Steck ist leer";
    }
    else
    {
        node* Temp = tail;
        tail = tail->next;
        delete Temp;
    }
}
 
// liefert den Wert des obersten Records
template <class T> T top()
{
    if(!tail) return 0;
    else return tail->item;
}
 
// Anzahl der Records im Stapeld
template <class T> int length()
{
    return anz_intems;
}
 
// true, wenn Stapel leer, sonst false
template <class T> bool empty()
{
    if(!anz_intems) return 1;
    else return 0;
}
};

 
class CMyStack
{
public:
    CMyStack();
    ~CMyStack();
    void Push(int d);
    int Pop();
    bool isEmpty();
    void Print();
    
private:
    struct Node
    {
        int d;
        Node *p;
    };
 
    Node *top;
};
 
CMyStack::CMyStack():top(NULL)
{
    
}
 
void CMyStack::Push(int d)
{
    Node *pv = new Node;
    pv->d = d;
    pv->p = top;
    top = pv;
}
 
int CMyStack::Pop()
{
    if (isEmpty())
    {
        return -1;
    }
    int temp = top->d;
    Node *pv = top;
    top = top->p;
    delete pv;
    return temp;
}
 
 
bool CMyStack::isEmpty()
{
    return top ? false : true;
}
 
void CMyStack::Print()
{
    while (top)
    {
        std::cout << Pop() << ' ';
    }
 
    std::cout << std::endl;
}
 
CMyStack::~CMyStack()
{
    while (top)
    {
        Node *pv = top;
        top = top->p;
        delete pv;
    }
 
}
 
void emptyStack(CMyStack & stack);
 
int main()
{
    CMyStack TrainBase, OneTrain, TwoTrain;
    std::ifstream in("trains.txt", std::ios::in);
    if (!in)
    {
        std::cout << "Cannot open file 'trais.txt' for reading" << std::endl;
        return 1;
    }
 
 
    while (!in.eof())
    {
        int pr;
        in >> pr;
        TrainBase.Push(pr);
    }
 
    while (!TrainBase.isEmpty())
    {
        int pr = TrainBase.Pop();
        switch (pr)
        {
            case 1:
                OneTrain.Push(pr);
                break;
            case 2:
                TwoTrain.Push(pr);
                break;
        }
    }
 
    OneTrain.Print();
    TwoTrain.Print();
    
    _getch();
    return 0;
}
 
void emptyStack(CMyStack & stack)
{
    if (stack.isEmpty())
    {
        std::cout << "Stack is empty" << std::endl;
    }
    else
    {
        std::cout << "Stack is not empty" << std::endl;
    }
}

template <class T>

// содержание файла
#include "Stack.h"

numberStack->pop<int>();