刪除頭功能中的內存泄露

Question

嗨，我在刪除頭功能中遇到內存泄漏。我想這可能是因爲我沒有放開頭，但我似乎無法找到放置它的正確位置。我正在考慮正確的位置，說L - > head = L-> head-> next;

data_t * removehead(list_t *L) { 
    data_t *temp = NULL; 
} 
if (L->head != NULL) { 
    temp = L->head->data_ptr; 
    L->head = L->head->next; 
    L->size--; 
} 
return temp; 
} 

有什麼想法？

Answer 1

這是一個有趣的問題，如果你不想聲明一個特定的變量，那麼你必須在L->head = ..之前完成它，否則你將不再有任何舊頭的參考。

但你總是可以有一個更可讀的方式：

element *old_head = L->head; 
temp = L->head->data_ptr; 
L->head = L->head->next; 
--L->size; 
free(old_head); 

我想知道的唯一的事情是發生了什麼老臉尖data_t*？因爲如果你沒有任何參考，它也會泄漏。

Answer 2

你可以有兩個功能，一個是顯示當前列表頭，而另一個滴/彈出當前列表頭，

data_t* 
listHead(list_t* lp) 
{ 
    if(!lp) return lp; 
    if(!lp->head) return NULL; 
    data_t* dp = lp->head->data; 
    return dp; 
} 

data_t* 
listPop(list_t* lp) 
{ 
    if(!lp) return NULL; 
    data_t* dp = NULL; 
    if(lp->head) 
    { 
    if(lp->head == lp->tail) lp->tail = NULL; 
    node_t* head = lp->head; 
    lp->head = lp->head->next; 
    dp = head->data; 
    nodeDel(head); 
    lp->size--; 
    } 
    return dp; 
} 

和完整的（單）鏈表;-)，

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

typedef void data_t; 
data_t* 
dataNew(data_t* dp,int size) 
{ 
    if(!dp) return NULL; 
    data_t* data = (data_t*)malloc(size); 
    if(!data) return data; 
    memcpy(data,dp,size); 
    return(data); 
} 
void 
dataDel(data_t* dp) 
{ 
    if(!dp) return; 
    free(dp); 
    return; 
} 

typedef struct 
{ 
    void* next; 
    data_t* data; 
} node_t; 
node_t* 
nodeNew(data_t* data) 
{ 
    node_t* np = (node_t*)malloc(sizeof(node_t)); 
    if(!np) return np; 
    np->next=NULL; 
    np->data = data; 
    return(np); 
} 
data_t* 
nodeDel(node_t* np) 
{ 
    if(!np) return np; 
    data_t* data = np->data; 
    free(np); 
    return(data); 
} 

typedef struct 
{ 
    int size; 
    node_t* head; 
    node_t* tail; 
} list_t; 

list_t* 
listNew() 
{ 
    list_t* lp = (list_t*)malloc(sizeof(list_t)); 
    if(!lp) return lp; 
    lp->head = lp->tail = NULL; 
    lp->size=0; 
    return(lp); 
} 
int 
listEmpty(list_t* lp) 
{ 
    int count=0; 
    if(!lp) return 0; 
    while (lp->head) 
    { 
     node_t* np; 
     data_t* data; 
     count++; 
     np = lp->head; 
     lp->head = lp->head->next; 
     data = np->data; 
     free(np); 
     free(data); 
    } 
    return count; 
} 
int 
listDel(list_t* lp) 
{ 
    if(!lp) return 0; 
    int count=listEmpty(lp); 
    free(lp); 
    return count; 
} 
int 
listCount(list_t* lp) 
{ 
    if(!lp) return 0; 
    return(lp->size); 
} 
data_t* 
listHead(list_t* lp) 
{ 
    if(!lp) return lp; 
    if(!lp->head) return NULL; 
    data_t* dp = lp->head->data; 
    return dp; 
} 
data_t* 
listTail(list_t* lp) 
{ 
    if(!lp) return lp; 
    if(!lp->tail) return NULL; 
    data_t* dp = lp->tail->data; 
    return dp; 
} 
node_t* 
listPush(list_t* lp, data_t* data) 
{ 
    if(!lp) return NULL; 
    if(!data) return NULL; 
    node_t* np = nodeNew(data); 
    if(!np) return np; 
    if(lp->tail) 
    { 
    lp->tail = lp->tail->next = np; 
    } 
    if(!lp->head) 
    { 
    lp->head = lp->tail = np; 
    } 
    lp->size++; 
    return np; 
} 
data_t* 
listPop(list_t* lp) 
{ 
    if(!lp) return NULL; 
    data_t* dp = NULL; 
    if(lp->head) 
    { 
    if(lp->head == lp->tail) lp->tail = NULL; 
    node_t* head = lp->head; 
    lp->head = lp->head->next; 
    dp = head->data; 
    nodeDel(head); 
    lp->size--; 
    } 
    return dp; 
} 

int 
main() 
{ 
    list_t* lp; 
    data_t* data; 
    int ndx; 
    if(!(lp = listNew())) 
    { 
    printf("error: cannot allocate list\n"); exit(1); 
    } 
    for(ndx=0; ndx<100; ++ndx) 
    { 
     data = (data_t*)malloc(100); 
     sprintf(data,"node:%d",ndx); 
     if(!listPush(lp,data)) 
     { 
     printf("error: cannot push %s\n",data); 
     free(data); 
     } 
    } 

    while(listCount(lp) > 0) 
    { 
     data = listPop(lp); 
     printf("data: %s\n",data); 
     free(data); 
    } 
}