Segfault in my stack implementation (C++) code, but cannot understand why - c++

Question

To set the record straight, I am fairly new to C++ and most of my experience in programming is in Java. I'm writing an array based stack implementation and I cannot seem to read any of the data saved in my stack.
Objects can be pushed and this seems to function normally. Commenting out the top() operation yields a successful output of zero, which seems to tell me that I know the item is at least being added to the array.
However, reading the item, I get a segfault error. After a quick google or two, I learned that a segfault means that there is an operation accessing data it does not have access to. This leads me to think that my top() function does not have access to the array. It is a private member of the class, but my previous knowledge of OOP tells me that a class method should have access to all private variables.
Could anyone help point me in the right direction here? (Apologies if the documentation is a bit excessive for such a primitive data structure, let me know if it should be removed).
Thanks! Code is below:
#include <iostream>
using namespace std;
/*
Class: arrayStack()
A simple stack implemented with a single array.
Handles char objects.
*/
class arrayStack {
int length; //cap on stack length
int count; //Keeps track of which element in the array to pop from.
char array[]; //Hold data here
public:
/*
arrayStack()
Constructor used to create a stack object. No default constructor exists, the length (l) is a required argument as a parameter to create a stack.
l space is reserved in the array and count is set to -1, the int value required for an empty stack.
*/
arrayStack(int l)
{
char array[l];
length = l;
count = -1;
}
/*
push() -- return type void.
Method to add a desired char element (o) to the stack.
*/
void push(char o)
{
array[count] = o;
count++; //Increment the counter to accurately pull element from array.
}
/*
pop() -- return type char.
Method to remove an element from the stack. Element is pulled from the stack and returned.
*/
char pop()
{
//temp space to store pulled element before returning.
char temp;
temp = array[count];
//Replace popped element with null to reduce memory waste. Then decrement counter for proper functioning of the stack.
array[count] = '\0';
count--;
return temp;
}
/*
top() -- return type char.
Method which returns the top element of the function without deleting it from the stack. Useful for inspection and testing, but functionally very similar to pop().
*/
char top()
{
//temp space to store pulled element.
char temp;
temp = array[count];
return temp;
}
/*
isEmpty() -- return type boolean.
Method which checks the stack for elements. If there are no elements, the method returns true. If there exists one or more elements, the method will return false.
Method is very simple-- a simple check against the count (int) variable.
*/
bool isEmpty()
{
if (count == -1) {
return true;
} else {
return false;
}
}
/*
size() -- return type int.
Method which returns the number of elements in the stack.
*/
int size()
{
return count++;
}
};
int main() {
arrayStack stack(10);
stack.push('c');
cout << stack.top(); //SEGFAULT OCCURS HERE.
cout << stack.isEmpty();
return 0;
}

Answer 1

Your member array is still uninitialized:
arrayStack(int l)
{
char array[l];
length = l;
count = -1;
}
Here, you create a new array (which I doubt is legal anyway, since C++ doesn't support VLA's. It should probably be
arrayStack(int l)
{
array = new char[l];
length = l;
count = -1;
}
You also need to implement a destructor to delete the allocated memory. Which means you also need a copy constructor and copy assignment operator.