Стек на шаблонах - оцените реализацию

template <typename T>
class Stack
{
private:
    size_t size;
    T* data;
public:
    Stack();
    void Push(T value);
    T Pop();
};
 
template <typename T>
Stack<T>::Stack()
{
    size = sizeof(T);
    data = new T;
}
 
template <typename T>
void Stack<T>::Push(T value)
{
    data = data + size;
    *data = value;
}
 
template <typename T>
T Stack<T>::Pop()
{
    int tmp = *data;
    data = data - size;
    T* ptr = data + size;
    ptr = nullptr;
    return tmp;
}

template <typename T>
class Stack
{
private:
    size_t size;
    size_t count;
    T* data;
public:
    Stack();
    ~Stack();
    void Push(T value);
    T Pop();
};
 
template <typename T>
Stack<T>::Stack()
{
    size = sizeof(T);
    data = new T;
    count = 0;
}
 
template <typename T>
Stack<T>::~Stack()
{
    delete [] (data - size * count);
}
 
template <typename T>
void Stack<T>::Push(T value)
{
    count++;
    data += size;
    data = new T;
    *data = value;
}
 
template <typename T>
T Stack<T>::Pop()
{
    count--;
    T tmp = *data;
    if (count > 0)
    {
        T* ptr = data;
        data -= size;
        delete ptr;
    }
    return tmp;
}

void main()
{
    Stack<POINT> stack;
    for(int i = 0; i < 5000; i++)
    {
        POINT pt = {i+10,i-5};
        stack.Push(pt);
        pt = stack.Pop();
        printf("%d %d\n", pt.x, pt.y);
    }
    getch();
}

struct vect
{
    int x, y, z;
};
 
int main()
{
    Stack <vect> arr;
    int x = 5, y = 6, z = 9;
    for (int i = 0; i < 500; i++)
    {
        vect tmp = {x++, y--, z+=2};
        arr.Push(tmp);
    }
    return 0;
}

int main()
{
    Stack <double> arr;
    //int x = 5, y = 6, z = 9;
    for (int i = 0; i < 200; i++)
    {
        arr.Push(i*3.4);
    }
    for (int i = 0; i < 200; i++)
    {
        cout << i << ". value = " << arr.Pop() << endl;
    }
 
    return 0;
}

template <class T>
class MyStack
{
public:
    MyStack<T>() : pointer(NULL) {}
    ~MyStack() { if (pointer) { while (pointer->prev) pointer = pointer->prev; clear(pointer); } }
    bool push(T val)
    {
        node *nw = new node(val);
        if (!pointer) pointer = nw;
        else
        {
            pointer->next = nw;
            nw->prev = pointer;
            pointer = nw;
        }
        return true;
    }
    bool pop(T &val)
    {
        if (!pointer) return false;
        if (!pointer->prev)
        {
            val = pointer->value;
            delete pointer;
            pointer = NULL;
        }
        else
        {
            val = pointer->value;
            pointer = pointer->prev;
            delete pointer->next;
            pointer->next = NULL;
        }
        return true;
    }
 
private:
    struct node
    {
        node(T val) : value(val), prev(NULL), next(NULL) {}
        T value;
        node *prev;
        node *next;
    };
    node *pointer;
    void clear(node *tmp) { if (tmp->next) clear(tmp->next); delete tmp; }
};

template <typename T>
Stack<T>::~Stack()
{
    if (count > 0)
        delete [] (data - size * count);
}

void main()
{
    Stack<POINT> stack;
    for(int i = 0; i < 5000; i++)
    {
        POINT pt = {i+10,i-5};
        stack.Push(pt);
        char* foo_arr= new char[1024];
        POINT pt_1 = {i+20,i-10};
        stack.Push(pt_1);
        POINT rpt_1 = stack.Pop();
        printf("%d %d\n", rpt_1.x, rpt_1.y);
        POINT rpt = stack.Pop();
        printf("%d %d\n", rpt.x, rpt.y);
        delete []foo_arr;
    }
    getch();
}