Stack class

const int max_stack = 10;
typedef int Stack_entry; // Now, stack data type is int

enum Error_code {
    succeed,
    overflow,
    underflow
};

class Stack{
public:
    Stack();
    Stack(const Stack & rhs);
    ~Stack();

    Stack & operator=(const Stack & rhs); // return Stack& for a=b=c

    bool empty() const;
    Error_code top(Stack_entry & item) const;
    Error_code pop();
    Error_code push(const Stack_entry & item);

private:
    int count;
    Stack_entry entry[max_stack];
};

Stack::Stack() {
    count = 0;
}

Stack::Stack(const Stack & rhs) : count(rhs.count) {
    for (int i=0; i<rhs.count; i++) {
        entry[i] = rhs.entry[i];
    }
}

Stack::~Stack() {

}

Stack & Stack::operator=(const Stack & rhs) {
    count = rhs.count;
    for (int i=0; i<count; i++) {
        entry[i] = rhs.entry[i];
    }

    return (*this);
}

bool Stack::empty() const{
    if (count > 0)
        return false;
    return true;
}

Error_code Stack::top(Stack_entry & item) const {
    Error_code stat = succeed;
    if (count == 0)
        stat = underflow;
    else
        item = entry[count-1];

    return stat;
}

Error_code Stack::pop() {
    Error_code stat = succeed;
    if (count == 0)
        stat = underflow;
    else
        count--;

    return stat;    
}

Error_code Stack::push(const Stack_entry & item) {
    Error_code stat = succeed;
    if (count == max_stack)
        stat = overflow;
    else
        entry[count++] = item;

    return stat;
}

int main(int argc, char * argv[]) {
    return 0;
}