Stos dynamiczny - problem z operatorem kopiującym

Dzień dobry. Robię sobie ćwiczonko odnośnie stosu dynamicznego i muszę napisać m.in. konstruktor kopiujący. I mam pewne kłopoty... nie wiem, jak do pitems przypisać kolejną wartość unsigned long (Item). Przy obecnej formie konstruktora mam błąd "invalid conversion from Item* to Item" i nie wiem, co zrobić. Inne opcje, jak np. użycie wyłuskania też nic nie dają. Jak ten konstruktor powinien wyglądać? Na inne metody nie patrzcie. Jeśli coś tam będzie źle, powinienem coś tam wykombinować, a niektóre jak np. operator= nie są jeszcze nawet napisane.

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

Cos takiego.

n0name_l napisał(a):

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

Jeszcze operator:

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

Dziękuję. No faktycznie sam bym na takiego rozwiązanie nie wpadł. Wszystko działa bez zarzutu, a ja jestem naumiany:)