Реализация стека с шаблонами

#include <iostream>
 
using namespace std;
 
template <class T>
class stack
{
    public:
        stack (int sz = 10);
        void push (T item);
        T pop ();
        ~stack();
 
    private:
        T* st;
        int top;
};
 
template <class T>
stack <T> :: stack (int sz)
{
    st = new T [sz];
    top = -1;
}
 
template <class T>
void stack <T> :: push (T item)
{
    st[++top] = item;
}
 
 
template <class T>
T stack <T> :: pop ()
{
    return st[top--];
}
 
template <class T>
stack <T> :: ~stack()
{
    delete [] st;
}
 
 
int main()
{
    stack <int> i1 ();
 
    i1.push(3);
 
 
 
    return 0;
}

#include "iostream"
#include "MyStack.h"
 
using namespace std;
 
int main()
{
    MyStack<int> i;
    i.push(1);
    
    system("pause >> null");
    return 0;
}

#pragma once
//------------------------------------------------------------
template<class T> class MyStack
{
private:
    unsigned int count;
    T *_v;
    struct Node
    {
        Node() : elem(0), next(0){}
        Node *next;
        T elem;
    };
    Node* head;
    Node* tail;
 
public:
    MyStack() :tail(0), head(0), count(0) {}
    ~MyStack();
    void push(T val);
    void pop();
    T top();
    bool empty();
    unsigned int size();
    void swap(MyStack &);
};
 
//------------------------------------------------------------
template<class T> MyStack<T>::~MyStack()
{
    while(head)
    {
        tail = head->next;
        delete head;
        head = tail;
    }
}
 
//------------------------------------------------------------
template<class T> void MyStack<T>::push(T val)
{
    Node *Temp = new Node;
    Temp->elem = val;
    if(tail == 0)
    {
        tail = Temp;
        count = 1;
    }
    else
    {
        Temp->next = tail;
        tail = Temp;
        count++;
    }
}
 
//------------------------------------------------------------
template<class T> bool MyStack<T>::empty() 
{
    if(tail == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}
 
//------------------------------------------------------------
template<class T> void MyStack<T>::pop()
{
    if(tail == 0)
    {
        std::cout << "The stack is empty\n";
    }
    else
    {
        Node* delptr = tail;
        tail = tail->next;
        delete delptr;
        count--;
    }
}
 
//------------------------------------------------------------
template<class T> T MyStack<T>::top()
{
    if(tail == 0)
    {
        std::cout << "The stack is empty\n";
    }
    else
    {
        return tail->elem;
    }
}
//------------------------------------------------------------
template<class T> unsigned int MyStack<T>::size()
{
    return count;
}
//------------------------------------------------------------
template<class T> void MyStack<T>::swap(MyStack& other)
{ 
    std::swap(_v, other._v);
    std::swap(count, other.count);
    std::swap(tail, other.tail);
}