双链表出现双重错误

Question

So I'm trying to do a method to clear a doubly linked list for school where the doubly linked list and nodes are defined as:

struct word_entry
{
    char *unique_word ;
    int word_count ;
} ;

struct node
{
    struct word_entry one_word ;
    struct node *p_previous ;
    struct node *p_next ;
} ;

struct linked_list
{
    struct node *p_head ;
    struct node *p_tail ;
    struct node *p_current ;
} ;

I have a method to clear a linked list by doing

int clear_linked_list( struct linked_list *p_list ) //return how many nodes were cleared
{
    if (p_list->p_head == NULL) {
        return 0;
    }
    else {
        int count = 0;
        struct node *curr = p_list->p_head;

        while (curr != NULL) {
            struct node *next = curr->p_next;

            free(curr->one_word.unique_word);
            free(curr);
            curr = next;
            count++;
        }

        return count;
    }
}

I do a free() on curr->one_word.unique_word because it's a malloc'd char array. I was taught to free when I use malloc, so that's there.

The issue I run into is I get a "bogus pointer (double free?)" and a core dump when I run the test file provided by my professor. I've worked on this for a few hours and can't seem to find out where (or how) I'm calling free twice.

Answer 1

When you loop through the list, you should constantly change the position of the head, so that even if you repeat clear_linked_list, you will not get an error.

int clear_linked_list(struct linked_list* p_list)  // return how many nodes were cleared
{
    if (p_list->p_head == NULL) {
        return 0;
    } else {
        int count = 0;
        while (p_list->p_head != NULL) {
            struct node* curr = p_list->p_head;
            p_list->p_head = p_list->p_head->p_next;

            free(curr->one_word.unique_word);
            free(curr);
            count++;
        }

        return count;
    }
}

Answer 2

When freeing memory it is a good practice to set NULL to pointers that were freed to avoid this kind of problems. So you should do:

free(curr->one_word.unique_word);
curr->one_word.unique_word=NULL; 
//if that one_word.unique_word was shared between multiples nodes that free could cause problems if you dont set it to NULL afterwards
free(curr);
curr=NULL; //or curr=next...

Also. Check that when you create the nodes that:

• *p_next is NULL on the last node of the double linked list
• *p_previous is NULL on the first node of the list

Answer 3

You don't null out p_head before you leave the clear function.

So, if you called it twice, you'd have problems (ie p_head would point to an already freed node). Likewise for p_tail .

Also, if you tried to add to the list again, you'd have similar problems.

Otherwise, your clear code is just fine.

So, can you prove that the list is constructed correctly (eg before you free , add a printf that prints out all the node's pointers before you free anything).