Rpn calculator: How to free an element that was popped from the stack?

Question

I will first add my code:

    typedef struct _stack stack;
    typedef struct _stack_element stack_element;

    struct _stack {
        stack_element* top;
    };

    struct _stack_element {
        stack_element* next;
        float value;
    };

    void stack_push(stack* astack, float value)
    {


        struct _stack_element *elem=calloc(1,sizeof(stack_element));

           elem->value=value;


          if(astack->top==NULL){
            astack->top=elem;
          }
          else{
            elem->next=astack->top;
            astack->top=elem;
          }

    }


    float stack_pop(stack* astack)
    {
    float Number;
      if(astack==NULL){
        Number=NAN;
        return Number;
      }
      else{

        Number=astack->top->value;
        astack->top=astack->top->next;
    }
      return Number;
    }

     void process(stack* astack, char* token)
    {
        /* HIER implementieren */
      //  printf("\n<Logik fehlt!>\n");

        if(is_number(token)==1){
          float number=atof(token);
          stack_push(astack, number);
        }

        if(is_add(token)==1){
          float Number1=stack_pop(astack);
          float Number2=stack_pop(astack);
          float result=Number1+Number2;
          stack_push(astack, result);

        }
        if(is_sub(token)==1){
          float Number1=stack_pop(astack);
          float Number2=stack_pop(astack);
          float result=Number2-Number1;
          stack_push(astack, result);

        }
        if(is_mult(token)==1){
          float Number1=stack_pop(astack);
          float Number2=stack_pop(astack);
          float result=Number1*Number2;
          stack_push(astack, result);

        }
        return;
    }

    void print_stack(stack *astack) {
        int counter = 0;
        printf("\n |xxxxx|xxxxxxxxxxxxxxxxxxx|xxxxxxxxxxxxxxxxxxx|xxxxxxxxx|\n");
        printf(" | Nr. | Adresse           | Next              | Wert    |\n");
        printf(" |-----|-------------------|-------------------|---------|\n");
        for (stack_element* elem=astack->top; elem != NULL; elem = elem->next) {
            printf(" | %3d | %17p | %17p | %7.3f |\n", counter, elem, elem->next, elem->value);
            counter++;
        }
        printf(" |xxxxx|xxxxxxxxxxxxxxxxxxx|xxxxxxxxxxxxxxxxxxx|xxxxxxxxx|\n");
    }

    stack* stack_erstellen() {
      struct _stack* Stack =(struct _stack*)calloc(1, sizeof(struct _stack));

      Stack->top=NULL;

    return Stack;

    }

    int main(int argc, char** args)
    {
        stack* astack = stack_erstellen();
        char zeile[MAX_STR];
        char* token;

        intro();
        while (taschenrechner_input(zeile) == 0) {
            // Erstes Token einlesen
            token = strtok(zeile, " ");

            while (token != NULL) {
                printf("Token: %s\n", token);
                // Stackoperationen durchführen    return;

                process(astack, token);
                // Nächstes Token einlesen
                token = strtok(NULL, " ");
                print_stack(astack);
            }

            printf("\nExtrahiere Resultat\n");
            float result = stack_pop(astack);
            print_stack(astack);

            if (astack->top != NULL) {
                while (astack->top != NULL) {
                    stack_pop(astack);   //Räume Stack auf
                }
                printf("\nDoes not Compute: Stack nicht leer!\n");
            } else if (result != result) {
                printf("\nDoes not Compute: Berechnung fehlgeschlagen!\n");
            } else {
                printf("\nDein Ergebnis:\t%7.3f\n\n", result);
            }
        }
        free(astack);
    }

I am new to coding. The code above is from a assignment for university. The function I had to create are:

• void stack_push(stack* astack, float value)
• void stack_pop(stack* astack)
• void process (stack* astack, char* token)
• stack* stack_erstellen() (this translated to "create_stack")

There is also another c file that is compiled together with this one but I am not allowed to change anything in so I did not add it to this post.

The calculator seems to work fine and the print_stack() function also suggests that the push and pop functions work as expected.

My problem is that I am not sure how to free the memory in the pop function that allocated in the push function. How do I free the elements of my stack?

am knew to describing technical problems like this so If anything lacks I'll gladly add more information.

Answer 1

My problem is that I am not sure how to free the memory in the pop function that allocated in the push function. How do I free the elements of my stack?

You need to save the next pointer before free()ing the element:

    float stack_pop(struct _stack *astack) {
        float Number;
        if (astack == NULL) {
            Number = NAN;
            // return Number; // no need for return here
        } else {
            Number = astack->top->value;
            struct _stack_element *tmp = astack->top->next; // save
            free(astack->top);                              // free
            astack->top = tmp;                              // restore
        }
        return Number;
    }

_{I took the liberty of formatting your code to my liking :)}

Also, consider using double instead of float.