pop()

Curbuser

Hi Leute!

Da ich hier schon oft kompetente schelte bekommen hab, frag ich mal euch.

zu meinem problem ich habe mir eine stack.h gebastelt und hier meine .c dazu:

#include <stdio.h>
#include <stdlib.h>  

#define stack_size 10
#define stacktype float

stacktype stack[stack_size];
int stackpos=-1;
//Funktion für pusch
void push (float x)
{    //um stack von -1 zu initialisieren
     if (stackpos<0)
      {
        stackpos=0;
      }

     //abfangen von überladung und else übergang in normal
     if (stackpos>9)
      {
         printf("Fehler Stack ist voll!!!!!\n" );
         stackpos=stack_size;       
      }
     else
      {
         stack[stackpos]=x;   
         stackpos++;
      }

}

//Funktion für pop
float pop() 
{     
      int x;

      //stackpos muss allein stehn um öfteres unterschreiten zu registrieren
      stackpos--;
      //abfangen von unterschreiten und else übergang in normal
      if (stackpos<0)
       { 
           printf("Fehler Stack ist leer!!!!!\n");
           stackpos=-1;
           return 0;
       }
      else
       {   //um nach letztem element stack mit -1 zu verlassen
           if (stackpos=0)
           {
              x=stack[stackpos];
              stackpos=-1;
              return x;
           }
           else
           {     
              return stack[stackpos];
           }
       }

} 
//funktion für top (gibt oberstes element aus ohne stackpos. zu ändern)   
void top()
{
      printf ("Letztes Stackelement war: %.0f\n",stack[stackpos-1]);
}

//funktion printStack gibt inhalt aus, ohne stack zu leeren.
void printStack()
{    
     int i;
     printf("Zeige Stackinhalt:\n");
     for (i=stackpos-1;i>-1;--i)
      {
        printf("Position [%d]: %.0f\n",i,stack[i]);            
      }
}

//funktion isEmpty überprüft ob sich elemente im stack befinden..
int isEmpty()
{
    if (stackpos<0)
    {
      return 1;
    }
    else
    {
      return 0;
    }
}

alles funzt ganz gut nur seit ich isEmpty in betrieb genommen hab popt er falsch hat wer nen tipp oder eine idee?
Ps:hab stackpos auf -1 um is empty zu betreben. da ja auf [0] werte stehn könnten...
Danke euch schon mal im vorhinein!!

//um nach letztem element stack mit -1 zu verlassen
           if (stackpos=0)

Schau dir deine Bedingung noch mal genau an.

Swordfish

Hm, das tolle an nem Stack ist doch, dass er dynamisch wächst...

#include <stdbool.h>
#include <stdlib.h>

typedef float stack_data_t;

typedef struct tag_stack {

	stack_data_t *data;
	size_t size;

} stack_t;

stack_t* create_stack( void )
{
	return calloc( 1, sizeof( stack_t ) );
}

void delete_stack( stack_t *stack )
{
	free( stack->data );
	free( stack );
}

bool is_empty( stack_t *stack )
{
	return stack->size == 0;
}

stack_data_t top( stack_t *stack )
{
	if( !is_empty( stack ) ) {

		return stack->data[ stack->size - 1 ];

	} else {

		return 0;
	}
}

bool push( stack_t *stack, stack_data_t value ) {

	stack_data_t *tmp = realloc( stack->data, ( ++stack->size ) * sizeof( stack_data_t ) );

	if( !tmp ) {

		--stack->size;
		return false;
	}

	stack->data = tmp;
	stack->data[ stack->size - 1 ] = value;

	return true;
}

stack_data_t pop( stack_t *stack ) {

	stack_data_t value = 0;
	stack_data_t *tmp = 0;

	if( is_empty( stack ) ) {

		return 0;
	}

	value = stack->data[ --stack->size ];

	if( stack->size ) {

		tmp = realloc( stack->data, stack->size * sizeof( stack_data_t ) );

		if( !tmp ) {

			++stack->size;
			return 0;
		}

		stack->data = tmp;

	} else {

		stack->data = 0;
	}

	return value;
}

cheers, Swordfish

Curbuser

danke pusher! is mir nicht aufgefallen! war schon blind!

und danke für die wortspende swordfish

Swordfish

Curbuser schrieb:

und danke für die wortspende swordfish

Just my 2 cents...

cheers, Swordfish

Swordfish schrieb:

Hm, das tolle an nem Stack ist doch, dass er dynamisch wächst...

was? also ich mag stacks lieber, die eine fest definierte grösse haben.

stack-freak schrieb:

Swordfish schrieb:

Hm, das tolle an nem Stack ist doch, dass er dynamisch wächst...

was? also ich mag stacks lieber, die eine fest definierte grösse haben.

Was natürlich sehr von der Umgebung abhängt.

Tim schrieb:

Was natürlich sehr von der Umgebung abhängt.

stimmt schon, aber so'n dynamischer stack hat ja auch 'ne grenze, allerdings weiss man nie wo. das verhalten eines stacks mit statischem speicher ist dagegen viel leichter vorhersehbar.