Stack

Hi all, I'm fairly new to C programming and am currently trying to create a stack just using pointers.

I have created a function 'peek' that will print out all of the integers that are stored in the stack.

I want to pass the stack by value, so no changes are made to it outside of the function.

This doesn't work, and the program just crashes...as I'm using pointers, I'm guessing that I am missing something out to do with memory.

The code does work, however, when I pass the stack by reference...

Code:

 peek(stack,sizeof(stack));

Code:

 
void peek(stack_t **stackptr, int size)
{
	stack_t* peek_element;
	int i,data;
	
	for ( i=0; i < size; i++)
	{
		peek_element = (*stackptr);       				
      	        data = peek_element->data; 	    				
		(*stackptr) = peek_element->next;
		printf("%d ", data);
	}
	
}

If anyone could either tell me what I am doing wrong, or point me in the right direction it would be greatly appreciated.

Thanks

Code:

peek(stack,sizeof(stack));

You'd probably want to pass the number of elements currently in the stack instead.

Ok, I tried that by incrementing 'size_stack' each time 'push' is called.

Then passing that value instead of sizeof(stack);

Had no effect

Here's an idea: Why don't you post a complete snippet of code that demonstrates the problem? Otherwise you are asking us to debug where you think the problem is rather than actually debugging your code. Debugging code is relatively easy compared to debugging other people's thoughts.

Sorry...didn't want to overwhelm you with all of my code.

Here it is anyway:

Stack.h (Using this so I get used to header files etc...)

Code:

typedef struct stack{
int data;
struct stack* next;
}
stack_t;

void push(int, stack_t** stackptr);
int pop(stack_t** stackptr);
void peek(stack_t** stackptr, int);

Stack.C

Code:

#include<stdio.h>
#include"stack.h"

stack_t** stack = NULL;  //Global variable as both functions use it.
int stack_size = 0;
int main()
{
	int a,b,c;

	printf("Enter any number on the keyboard ");
	scanf("%d", &a);					 
				 		
	printf("Enter any number on the keyboard ");
	scanf("%d", &b); 							
		
	printf("Enter any number on the keyboard ");
	scanf("%d", &c); 							

	push(a, &stack);
	push(b, &stack);
	push(c, &stack);
	
	peek(stack, stack_size);

	printf("%d ", pop(&stack));
	printf("%d ", pop(&stack));
	printf("%d ", pop(&stack));
	
 return 0;
}

void push(int data, stack_t **stackptr)   
{
	stack_t* push_element;
                
	push_element = (stack_t*)  malloc(sizeof(stack_t));	//Allocating memory 		
	push_element->data = data; 					//Data assigned
	push_element->next = (*stackptr);				//Next is now equal to the address  [which is of pointer type]  that stackptr  [pointer to a pointer]  points to.  
	(*stackptr) = push_element;   				//Address stackptr points to now stores new_element
	stack_size++;
}

int pop(stack_t **stackptr)
{
	int data;
	stack_t* pop_element;

	pop_element = (*stackptr);       				//Old_element is now equal to the address  [which is of pointer type]  that stackptr  [pointer to a pointer]  points to.  	
      data = pop_element->data; 	    				//Data is copied 
	(*stackptr) = pop_element->next;  				//Value pointed to by stackptr is = old_element->next.              
	free(pop_element); 		     				//Remove pointer after usage.
	return data;
	stack_size--;
}

void peek(stack_t **stackptr, int size)
{
	stack_t* peek_element;
	int i,data;
	
	for ( i=0; i < size; i++)
	{
		peek_element = (*stackptr);       				//Old_element is now equal to the address  [which is of pointer type]  that stackptr  [pointer to a pointer]  points to.  	
      	data = peek_element->data; 	    				//Data is copied 
		(*stackptr) = peek_element->next;
		printf("%d ", data);
	}
	
}

You don't need a pointer to a pointer for your stack. You only need that for your function calls, so they can update the passed stack. You really don't need any arguments to your functions, though it's a good idea, since you're using a global anyway...

Also, because 'stack' is a pointer to a pointer, doing '&stack' is in effect a pointer to a pointer to a pointer. All you need to have is a single pointer:

Code:

foo_t *stack;
...
push( &stack, bar );

Quzah.

Sorry, I am extremely confused...I've spent most of the day doing this thing, and I hate pointers...

I no longer need to use

Code:

stack_t **stack

but use

Code:

stack_t *stack

So now that is simply a pointer of type 'stack_t'.

Is this all that is needed to be changed? I have done so, and the program compiles far better now (less errors :$) but the same problem occurs....

Program crashes after Peek has been called.

No its ok, sorry, works fine now, my mistake!!!

Thanks

Hi, me again...I'm really sorry to keep asking questions, but I've spent the last hour or so trying to work out why, when I enter in 3 values, when it comes to popping the last value, it will come out as 0.

Why is that happening? Surely if the 'peek' function displays all the values correctly, and the stackptr is returned to its orginal value before the function, then pop should have no problems?

I can't think what is wrong with it...

Well for one thing, you never check to see if your stack is empty before you go popping it apart. Also, you have a return statement before you decrement the stack size, so that line of code never happens. When you return, nothing after the return happens.


Quzah.

Hi all, me again. I had my programming working completely correctly, and that was using the GCC windows compiler.

Now I move onto fedora core, it's giving me alot of weird errors, errors that I can't see....

here is my complete code, again!

Code:

#include<stdio.h>

#include"stack.h"



stack_t* stack = NULL;  		//Global variable as both functions use it.

int stack_size = 0;		//Size of stack (number of values inside it)

int main(int argv, char*argc[])
{

	int a,b,c,d;

	printf("Enter any 4 integers seperated by spaces ");

	scanf("%d %d %d %d", &a,&b,&c,&d);			          //Read in user input					



	push(a, &stack);							    //Push each value onto the stack

	push(b, &stack);

	push(c, &stack);

	push(d, &stack);

	

	peek(&stack,stack_size);					    //Call peek

	printf("::%d:: is popped off the stack\n", pop(&stack)); //Pop a value off the stack

	peek(&stack,stack_size);					    //Call peek

	printf("::%d:: is popped off the stack\n", pop(&stack)); //Pop a value off the stack	

	peek(&stack,stack_size);					    //Call peek

 return 0;

}



/*::::::::::::::FUNCTIONS::::::::::::::*/





void push(int data, stack_t **stackptr)   			//Pushes integer onto the stack

{

	stack_t* push_element; 						//Stack pointer

                

	push_element = (stack_t*)  malloc(sizeof(stack_t));	//Allocating memory 		

	push_element->data = data; 					//Data assigned

	push_element->next = (*stackptr);				//Next is now equal to the address  [which is of type pointer ]  that stackptr  [pointer to a pointer]  points to.  

	(*stackptr) = push_element;   				//Address stackptr points to now stores new_element

	stack_size++;							//Increment stack size, as integer has been pushed

}



int pop(stack_t **stackptr)						//Pop integer off the stack

{

	int data;								//Used to store data

	stack_t* pop_element;						//Stack pointer

	if (stack_size != 0)						//If stack is not empty

	{

		pop_element = (*stackptr);       			//pop_element is now equal to the address  [which is of type pointer ]  that stackptr  [pointer to a pointer]  points to.  	

      	data = pop_element->data; 	    			//Data is copied 

		(*stackptr) = pop_element->next;  			//Stackptr now points to pop_element->next.              

		free(pop_element); 		     			//Remove pointer after usage.

		stack_size--;						//Decrement stack size, as integer has been popped.

		return data;						//Return the data that has been popped

	}

}



void peek(stack_t **stackptr, int size)				//Displays all values in the stack

{

	stack_t* peek_element;						//Stack pointer

	stack_t* store_element;						//Stack pointer	

	int i;	
	int data;
	store_element = (*stackptr);					//Stack pointer stores address that *stackptr points to.

	printf("Peeking at stack:: ");			

	for ( i=0; i < size; i++)					//Loop untill i = stack size.

	{

		peek_element = (*stackptr);       			//Peek_element is now equal to the address  [which is of type pointer ]  that stackptr  [pointer to a pointer]  points to.  	

      	data = peek_element->data; 	    			//Data is copied 

		(*stackptr) = peek_element->next;			//Stackptr now points to peek_element->next 

		printf("%d ", data);					//Prints value of data

	}

	printf("\n");							//New line

	(*stackptr) = store_element;					//*stackptr now points to store_element, restoring it's orginal value.

}

The following are the errors I get...

stack2.c: In function `peek':
stack2.c:4: error: parameter `stack' is initialized
stack2.c:5: error: parameter `stack_size' is initialized
stack2.c:7: error: syntax error before '{' token
stack2.c:43: error: syntax error before "if"
stack2.c:60: error: syntax error before "store_element"

I can't see any errors in what I have done? I have bolded them so you can find them easily.

I'm really sorry to keep on asking, but I just cannot understand why this isn't working.

My guess is a prototype in your stack.h is missing a ) from looking at the first error.

Sorry, what's a prototype?


This is my stack.h

Code:

typedef struct stack{
int data;
struct stack* next;
}
stack_t;

void push(int, stack_t** stackptr);
int pop(stack_t** stackptr);
void peek(stack_t** stackptr, int);