LinkedList - malloc을 사용하여 할당된 메모리를 해제하는 방법

LinkedList - malloc을 사용하여 할당된 메모리를 해제하는 방법

저는 아래와 같이 Singlely Linked List를 구성하는 아주 간단한 C 코드를 가지고 있는데 malloc을 사용하여 각 노드에 대해 동적으로 메모리를 할당합니다.코드가 끝나면 할당된 각 노드에 대해 메모리를 해제하고 싶은데 어떻게 해야 할지 고민 중이었습니다. 헤드 노드에서 먼저 시작해서 해제하면 후속 노드에 대한 포인터가 유실되고 메모리 누수가 발생합니다.

다른 방법으로는 헤드 노드에서 시작하여 별도의 포인터 배열 등에 노드 포인터를 계속 저장하고, 노드 포인터를 저장하는 동안 목록을 테일 포인터까지 이동하고, 테일 노드에 도달하면 다른 포인터 배열에도 저장하고 헤드 노드가 자유로워질 때까지 배열 인덱스에서 뒤로 해제하기 시작합니다.

그것만이 제가 하려는 것을 이룰 수 있는 유일한 방법인가요?

second buffer를 사용하고 싶지 않을 경우 어떻게 해야 합니까?

#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
   }


}

일반적인 방법은 다음과 같습니다(사이비 코드 먼저).

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.

기본적인 아이디어는 노드를 별도의 변수에서 자유롭게 한 후 자유롭게 하기 전에 다음 변수로 이동하는 것입니다.

제안하는 전체 목록이 아니라 한 번에 하나의 노드만 기억하면 됩니다.

코드에 추가할 필요가 있는 사항에 관해서는 삭제 중에 다음을 사용할 수 있습니다.head지속적으로 업데이트되는 리스트 헤드로서(예정대로).curr현재 삭제 중인 항목을 저장하려면:

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.
}

이것은 단지 일부 연산에 대해 C "속기"의 이점을 이용하기 때문에 위의 의사 코드보다 약간 짧습니다.

나는 다음과 같은 것을 사용합니다.

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

무료 코드는 다음과 같습니다.

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

또한 당신의 malloc 후에 당신이 mem이 성공적으로 할당되었는지 확인하고 싶은 것을 추가하고 싶습니다.비슷한 것

if(curr)

위와 같은 논리를 사용하여 목록을 이동합니다.curr->다음 포인터를 어딘가에 저장하고 curr 구조를 풀고 저장된 curr->다음 포인터로 curr를 할당합니다.

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__);

some_program.c PS 헤더 시스템의 예IO는 위와 같은 헤더가 더 많은 그룹입니다! :)

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 .... 

언급URL : https://stackoverflow.com/questions/7025328/linkedlist-how-to-free-the-memory-allocated-using-malloc