How to create an empty stack? - c

Question

I'm trying to create a stack where I can push integers into it. So far I have this:
#include <stdio.h>
#define N 20
typedef struct {
int data[N]; // array of at most size N
// N should be a constant declared globally
int top;
} stack_t;
void push(stack_t *stack, int element);
int main(){
void push(stack_t *stack, int n) {
if (stack->top == N - 1) {
printf("Warning: Stack is full, You can't add'\n");
return;
} else {
stack->data[++stack->top] = n;
}
}
stack_t * e_stack; // Empty stack created
push(e_stack, 2);
}
However, this code gives a runtime error. I assume it's because this part is wrong:
stack_t * e_stack; // Empty stack created
(That probably didn't create an empty stack)
But I know how is it wrong

Answer 1

You're right, all you've done is created a pointer that points at...something, but probably not a stack_t. You need to allocate something to point at. See malloc. Then you'll need to initialize stack_t::top to -1 or some other value. Zero probably won't work here since that index would likely be the first item in the stack.

Answer 2

Here is an example that I wrote a while ago. It basically pushes integers onto a stack, and pops the most recently added item to the stack. Note, the popping of items is probably not the best way to doing it, there are certainly better ways.
Example code:
#include <stdio.h>
#include <stdlib.h>
#define N 20
typedef struct {
int data[N]; //better to use a dynamic array instead here
int top;
} stack_t;
stack_t *create_empty_stack(void);
void push(stack_t *stack, int value);
int pop(stack_t *stack);
int
main(void) {
stack_t *stack;
stack = create_empty_stack();
push(stack, 10);
push(stack, 20);
push(stack, 30);
printf("Popped: %d\n", pop(stack));
printf("Popped: %d\n", pop(stack));
printf("Popped: %d\n", pop(stack));
printf("Popped: %d\n", pop(stack));
free(stack);
return 0;
}
void
push(stack_t *stack, int value) {
if (stack->top == N - 1) {
printf("Warning: Stack is full, You can't add'\n");
return;
} else {
stack->data[stack->top] = value;
(stack->top)++;
}
}
int
pop(stack_t *stack) {
if (stack->top > 0) {
(stack->top)--;
return stack->data[stack->top];
} else {
//definetly better way to do this. I will let you decided how you want to implement this.
printf("Tried to pop empty stack!\n");
exit(EXIT_FAILURE);
}
}
// Since you are using a fixed sized array, creating an empty stack in this case is easy.
stack_t
*create_empty_stack(void) {
stack_t *stack = malloc(sizeof(*stack));
if (stack == NULL) {
printf("Cannot allocate stack\n");
exit(EXIT_FAILURE);
}
stack->top = 0;
return stack;
}

Answer 3

Either (as other answers suggest) allocate a memory zone and get a pointer to stack_t on the heap and initialize it correctly (perhaps thru a create_empty_stack function) or declare a stack_t local variable (on the call stack), initialize it explicitly, and pass a pointer to it:
stack_t locstack = {.data={}, .top=0};
push(&locstack, 2);
BTW, as commented by Jonathan Leffler, your code is not standard C99 or C11, because nested functions are not allowed in standard C. You are (probably incorrectly) using some GCC extension. You should define the push function outside of (and before) main. If you care about efficiency, define it as static inline void push(stack_t *stack, int n) .... to get it inlined.
Notice that if you want to accept arbitrarily sized stacks, consider using some flexible array member, and grow them (once in a while) as needed (think of some int newsize = 4*stack->size/3+2; when the stack gets full, then stack_t*newstack = malloc(sizeof(stack_t)+newsize*sizeof(int)); etc....) and only use heap allocated pointers, you could consider keeping both top and size as fields of stack_t and have data[] as its (last) flexible array member. In that case push would probably return a (possibly updated) pointer.
BTW, as soon as you are using some heap allocation like malloc, you always should handle failure, at the very least as:
stack_t* pstack = malloc(sizeof(stack_t));
if (pstack==NULL) { perror("malloc"); exit(EXIT_FAILURE); };
(if you have some
If using GCC, read more about its command options (their order is important). I recommend compiling with gcc -std=c99 -Wall -Wextra -g (on your original code, that should give some useful diagnostics), improve your code till you get no warnings, then use the gdb debugger.