What is going on with my ArrayStack here? - c++

Question

So I have been trying to implement an arrayStack but I seem to have issues popping more than 100 elements. My program just stops working when it hits hundred. It seems that there is an issue with the push and pop but don't quite understand what my problem is.
#ifndef _ARRAYSTACK_1_HPP_
#define _ARRAYSTACK_1_HPP_
#include <stddef.h>
#include "StackADT.h"
#define DEFAULT_SIZE 50
template<class T>
class ArrayStack_1 : public StackADT<T> {
private:
T *arrayStack;
int index;
int maxSize;
public:
// a constructor for the arrayStack that creates and arrayStack of a given size
ArrayStack_1(int size = DEFAULT_SIZE) {
maxSize = size;
index = 0;
arrayStack = new T[size];
}
public:
// a constructor for the arrayStack that creates and arrayStack of a given size
ArrayStack_1(int size = DEFAULT_SIZE) {
maxSize = size;
index = 0;
arrayStack = new T[size];
}
//a destructor that deletes the arrayStack
~ArrayStack_1() {
delete[] arrayStack;
}
bool Empty() {
return index==0;
}
void Push(T& item = 0) {
if (index<maxSize) {
arrayStack[index]= item;
index+=1;
}else {
T* tempArrayStack = arrayStack; //making a copy of the array stack
maxSize+=1;
arrayStack = new T[maxSize];
for (int i=0; i<maxSize; i++){
arrayStack[i]=tempArrayStack[i];
}
arrayStack[index]=item;
index+=1;
delete[] tempArrayStack;
}
}
T Pop() {
if(arrayStack[index]==0){
return 0;
}else {
T element = arrayStack[index];
index--;
return element;
}
}
}

Answer 1

Likely all you should do is change arrayStack[index]==0 to index == 0 in your Pop function. Otherwise you risk accessing arrayStack with negative index which is undefined behaviour (likely a cause of your crash).
Also, when you are reallocating the stack, you should increase the stack size before the reallocation. I.e. swap these lines:
T* arrayStack = new T[maxSize];
maxSize+=1;
Furthermore, you don't assign the new value of arrayStack to your member variable - you define a new local variable in this code. Overall these lines should read:
this->arrayStack = new T[++maxSize];
(Note, you don't have to write this->arrayStack, simple arrayStack = ... will do the job - it's just there for clarity of intent)
And don't forget to delete tempArrayStack, otherwise you leak memory.
Edit
These lines should also be swapped:
index+=1;
arrayStack[index]=item;
and again, you could use ++ - in this case the postfix version:
arrayStack[index++] = item;
Learn about the difference for example here versus here

Answer 2

You really should step through this code to see what it's doing. I'm not sure how you would successfully make it to 100 iterations.
You need to pay more attention to when you are incrementing/decrementing. Sometimes you increment before you set the item, and other times you increment after you set the item.
You're pushing a reference instead of a pointer (and your arrayStack should be a pointer list).
You should double the size when you hit an overflow condition to ensure you don't have to recreate the array on every push.
You have a substantial memory leak because you never delete arrayStack when you increase its size.
You are allocating a local variable and doing nothing with it.