Stos dynamiczny - problem z operatorem kopiującym

#ifndef STACK_H_
#define STACK_H_

typedef unsigned long Item;

class Stack
{
private:
    enum {MAX = 10};
    Item * pitems;
    int size;
    int top;
public:
    Stack(int n = MAX);
    Stack(const Stack & st);
    ~Stack();
    bool isempty() const;
    bool isfull() const;
    //push() zwraca false, kiedy stos jest pelny, true w pozostalych przypadkach
    bool push(const Item & item);
    //pop() zwraca false, kiedy stos jest pusty, true w pozostalych przypadkach
    bool pop(Item & item);
    Stack & operator=(const Stack & st);
};
#endif // STACK_H_
 

 #include "stack.h"
#include <iostream>

Stack::Stack(int n)
{
pitems = new Item[n];
size = n;
top = 0;
}

Stack::Stack(const Stack & st)
{
if (top < MAX)
pitems[top++] = st.pitems;
else
    std::cout << "Stos pelen. Nie mozna wrzucic kolejnego elementu.\n";
}

Stack::~Stack()
{
delete [] pitems;
std::cout << "Stos usuniety.\n";
}

bool Stack::isempty() const
{
    return top == 0;
}

bool Stack::isfull() const
{
    return top == MAX;
}

bool Stack::push(const Item & item)
{
    if (top < MAX)
        {pitems[top++] = item;
    return true;
        }
        else
            return false;
}

bool Stack::pop(Item & item)
{
    if (top > 0)
    {
        item = pitems[--top];
        return true;
    }
    else
        return false;
}

Stack & Stack::operator=(const Stack & st)
{

}

class Stack {
    // blablabla
public:
    Stack(const Stack& s) {
        this->size = s.size;
        this->tab = new unsigned long[s.size];
        memcpy(this->tab, s.tab, s.size*sizeof(unsigned long));
    }
    
private:
    unsigned long* tab;
    unsigned long size;
};
 
int main() {
    return 0;
}

Stack(const Stack& s) {
        this->size = s.size;
        this->tab = new unsigned long[s.size];
        memcpy(this->tab, s.tab, s.size*sizeof(unsigned long));
    }

Stack& operator =(const Stack& s) {
        if (this!=&s) {
                delete[] tab;
                this->size = s.size;
                this->tab = new unsigned long[s.size];
                memcpy(this->tab, s.tab, s.size*sizeof(unsigned long));
        }
        return *this;
}