Create Stack in C++ with Push, Pop etc - c++

Question

We are trying to create a C++ program that works like a stack.
The following instructions are given:
There should be several methods:
We have to use this definition of the StackElement:
struct StackElement {
int digit;
StackElement* predecessor;
};
The problem now is how to create the push-function without an next parameter as there was with ordinary lists. The same for the pop function.
We accomplished to get push() create a new StackElement and pop() delete the new Element, but with 2 new Elements, those methods aren't working properly.
Global parameter stack0:
StackElement *stack0 = new StackElement;
This is the code for the push-function:
StackElement push(int z){
StackElement *stack1 = new StackElement;
stack1->digit = z;
stack1->predecessor = NULL;
stack0->predecessor = stack1;
stack1 = stack0;
This is the pop() method:
void pop(){
StackElement *stack1 = new StackElement;
if (stack0!=NULL){
stack1->digit = 0;
stack0->predecessor = NULL; //predecessor = NULL;
}
}
And finally the main method:
int main()
{
int z;
create();
cout << "Which number to the stack?" << endl;
cin >> z;
push(z);
pop();
print();
return 0;
}
We thought about creating a new StackElement, that would work as a 'pseudo'-StackElement and would always stay on top so that the 'real' element on the top would always be the predecessor of the pseudo-Element - but we think this would be against how the stack should work.
So do you guys have any clues on how to proceed? Is there something we are just missing?

Answer 1

1st) Why not using std::stack?
2nd) Stack should be LIFO. That means your stack0 should always be the newest one... This leads to:
StackElement* stack0 = NULL; // until C++11
// StackElement* stack0 = nullptr; // since C++11
void push(int z) {
StackElement *stack1 = new StackElement;
stack1->digit = z;
stack1->predecessor = stack0;
stack0 = stack1;
}
void pop() {
if(stack0) {
StackElement *tmp = stack0;
stack0 = stack0->predecessor;
delete tmp;
}
}
You don't need the allocate a new one in the pop function. This will end in a huge memory leak.
What you meant by pseudo is called root element and is sometimes used in sequences. But not necessary here, since stack0 is the root or in this case the end (the first element and the end).
A better approach would be to encapsulate it in a class as ryrich mentioned in his answer. And the best approach would be using the C++-given std::stack.

Answer 2

You're on the right track here. To keep track of your elements, you need a class. Something like:
class Stack{
private:
StackElement *last_data, *first_data;
public:
Stack():last_data(NULL), first_data(NULL){}
void push(int digit);
void pop();
};
Have the push/pop functions part of the Stack class. For example, push:
void Stack::push(int digit)
{
StackElement *p=new StackElement();
p->digit = digit;
if(last_data)
p->predecessor=last_data;
else // empty stack
{
p->predecessor=NULL;
first_data = p;
}
last_data=p;
}
Hope this helps.
Edit: I'll add pop function for completeness:
void Stack::pop()
{
if (last_data)
{
StackElement *tp = last_data;
last_data = last_data->predecessor;
delete tp;
}
}

Answer 3

if the stack is full and we try to put something in it then it will give us the error of stack overflow
void IntStack::push()
{
clrscr();
int num;
if(top>=stackSize)
cout<<"stack Overflow"<<endl;
else
{
cout<<"Enter Number=";
cin>>num;
top++;
stackArray[top]=num;
}
}