LinkedList – So geben Sie den mit malloc zugewiesenen Speicher frei

Ich habe einen sehr einfachen C-Code zum Erstellen einer einfach verknüpften Liste wie unten, in der ich Speicher für jeden Knoten dynamisch mit malloc zuweise. Am Ende des Codes möchte ich den Speicher für jeden zugewiesenen Knoten freigeben und habe mich gefragt, wie ich vorgehen soll. Wenn ich zuerst vom Hauptknoten aus beginne und ihn freigebe, gehen die Zeiger auf die nachfolgenden Knoten verloren und es kommt zu einem Speicherleck.

Ein anderer Weg ist, am Kopfknoten zu beginnen und den Knotenzeiger in einem separaten Array von Zeigern oder so etwas zu speichern, die Liste bis zum Endzeiger zu durchlaufen, während die Knotenzeiger gespeichert werden, und sobald der Endknoten erreicht ist, speichern Sie diesen auch in dem anderen Array von Zeiger und starten Sie die Freigabe von diesem Array-Index rückwärts, bis der Kopfknoten freigegeben ist.

Ist das der einzige Weg, um das zu erreichen, was ich versuche?

Falls ich keinen zweiten Puffer verwenden möchte, wie gehe ich vor?

#include "stdio.h"
#include "stdlib.h"

struct lnk_lst 
{
   int val;
   struct lnk_lst * next;
};

typedef struct lnk_lst item;


main()
{
   item * curr, * head;
   int i,desired_value;

   head = NULL;

   for(i=1;i<=10;i++) 
   {
      curr = (item *)malloc(sizeof(item));
      curr->val = i;
      curr->next  = head;
      head = curr;
   }

   curr = head;


   while(curr) {
      printf("%d\n", curr->val);
      curr = curr->next;
   }

  //How to free the memory for the nodes in this list?
   for(i=1;i<=10;i++)
   {
       free()//?? What logic here
   }


}

Der übliche Weg ist mit (Pseudo-Code zuerst):

node = head              # start at the head.
while node != null:      # traverse entire list.
    temp = node          # save node pointer.
    node = node.next     # advance to next.
    free temp            # free the saved one.
head = null              # finally, mark as empty list.

Die Grundidee besteht darin, sich den zu befreienden Knoten in einer separaten Variablen zu merken und dann zum nächsten vorzurücken, bevor er freigegeben wird.

Sie müssen sich nur daran erinnern eines Knoten auf einmal, nicht die gesamte Liste, wie Sie vorschlagen.

In Bezug auf das, was Sie Ihrem Code hinzufügen müssen, können Sie während des Löschens verwenden head als ständig aktualisierter Listenkopf (so wie es sein soll) und curr So speichern Sie das Element, das Sie gerade löschen:

while ((curr = head) != NULL) { // set curr to head, stop if list empty.
    head = head->next;          // advance head to next element.
    free (curr);                // delete saved pointer.
}

Dies ist etwas kürzer als der obige Pseudo-Code, einfach weil es für einige Operationen die C-Kurzschrift nutzt.

Ich benutze so etwas:

for (p = curr; NULL != p; p = next) {
    next = p->next;
    free(p);
}

Ihr kostenloser Code sollte wie folgt aussehen:

lnk_lst temp = null;
while(head) 
{
  temp = head->next;
  free(head);
  head = temp;
}

Außerdem möchte ich nach Ihrem Malloc hinzufügen, dass Sie wahrscheinlich überprüfen möchten, ob das Speicher erfolgreich zugewiesen wurde

if(curr)

Sie durchlaufen die Liste mit der gleichen Logik wie oben. Sie speichern den Curr->Next-Zeiger irgendwo, geben die Curr-Struktur frei und weisen Curr den gespeicherten Curr->Next-Zeiger zu

Inhalt von Garbage Collector.h

#include <stdlib.h>
#include <stdint.h>
#define Stack struct _stack
#define _MALLOC_S(type,num) (type *)_GC_malloc(sizeof(type)*num)
#pragma pack(1)

//Structure for adressing alocated memory into.

Stack {

    int *adress_i;
    char *adress_c;
    float *adress_f;
    double *adress_d;
    Stack *next;
};

//Safe malloc

void *_GC_malloc(size_t size)
{
    void* ptr = malloc(size);
    if(ptr == NULL)
        return _GC_malloc(size);
    else
        return ptr;
}

//Push new element on Stack after every malloc

void Add_New(int *i, float *f , double *d , char *c , Stack *p)
{
    Stack *q =  _MALLOC_S(Stack,1);

        q->adress_i = i;
        q->adress_f = f;
        q->adress_c = c;
        q->adress_d = d;

        q->next = p->next;
        p->next = q;
        q = NULL;
}

//before ending program remove adresses that was allocated in memory, and pop entire Stack

void Free_All(Stack *p)
{
    //free head (dummy element)
    Stack *Temp = p->next;
    Stack *_free = p;
    free(_free);

    void *oslobodi;

    while(Temp != NULL)
    {
        _free = Temp;
        Temp = _free->next;

        if(_free->adress_i != NULL){
            oslobodi = _free->adress_i;
            free((int *)oslobodi);
        }
        else if(_free->adress_c != NULL){
            oslobodi = _free->adress_c;
            free((char *)oslobodi);
        }
        else if(_free->adress_f != NULL){
            oslobodi = _free->adress_f;
            free((float *)oslobodi);
        }
        else{
            oslobodi = _free->adress_d;
            free((double *)oslobodi);
        }

        free(_free);
    }

    _free = p = Temp;
}

/*  
    declare variable (var) and dinamicly alocate memory with simple macro, 
    and add to stack of linked list
*/

#define obj_int(var)        int *var = _MALLOC_S(int,1);        *var = 0;   Add_New(var, NULL, NULL, NULL, Head); 
#define obj_char(var)       char *var = _MALLOC_S(char,1);  *var = 0;   Add_New(NULL, NULL, NULL, var, Head);
#define obj_float(var)      float *var = _MALLOC_S(float,1);    *var = 0;   Add_New(NULL, var, NULL, NULL, Head);
#define obj_double(var)     double *var = _MALLOC_S(double,1);  *var = 0;   Add_New(NULL, NULL, var, NULL, Head);
#define obj_struct(_type,_name) struct _type _*name = (struct _type *)malloc(sizeof(struct _type));

#define _INIT_ROW(var,num)  for(int i = 0; i < num; i++) var[i] = 0;

/*
    same, but for row!

*/

#define row_int(var, num)   int *var =  _MALLOC_S(int,num);     _INIT_ROW(var,num)  Add_New(var, NULL, NULL, NULL, Head); 
#define row_char(var, num)  char *var =  _MALLOC_S(char,num);       _INIT_ROW(var,num)  Add_New(NULL, NULL, NULL, var, Head);
#define row_float(var, num) float *var =  _MALLOC_S(float,num);     _INIT_ROW(var,num)  Add_New(NULL, var, NULL, NULL, Head);
#define row_double(var, num)    double *var =  _MALLOC_S(double,num);   _INIT_ROW(var,num)  Add_New(NULL, NULL, var, NULL, Head);
#define string(var, value)  row_char(var, (strlen(value)+1)) strcpy(var, value);

/* with this you create a Stack and allocate dummy element */

#define Main(_type) _type main(void) { Stack *Head = _MALLOC_S(Stack,1); Head->next = NULL; Stack *_q_struct;

/* with this macro you call function for dealocate memory (garbage collecting)*/

#define End         Free_All(Head); }

/*same thing for the other functions*/

#define Function(name_function, _type, ...) _type name_function(##__VA_ARGS__) { Stack *Head = _MALLOC_S(Stack,1); Head->next = NULL;
#define End_Ret(ret_var)            Free_All(Head); return (ret_var); }
#define Call(name_function, ...)        name_function(##__VA_ARGS__)

#define Define_Function(name_function, _type, ...) _type name_function(##__VA_ARGS__);

Beispiel für some_program.c PS-Header systemIO ist eine Gruppe von mehr Headern wie dem obigen! 🙂

Main(void)          

     int num_elements = 10;

     row_int(row_elements, num_elements); //alocating row_elements object

     for(int i = 0; i < num_elements; i++)
          row_elements[i] = i; //initializing row_elements

End //Garbage delete row_elements and end of program

// row_int[0] = 0, row_int[1] = 1 ....