将元素添加到队列时在C.Segfault中设计队列

Question

I am having a problem with a queue program I am writing in C. This is a circular queue, so the last item must also point to the first item. The problem exists within the addQueue function. First I check whether the head pointer is set to NULL, if it is then I add the first item to the queue. However, head is not equal to NULL, then I add the item to the end of the queue. I create an iterate pointer to iterate until it finds the end when: iterate->next == *head; The problem I am having is that when I create iterate and set it to *head, it is not operating as it should. Here is my code and the output I have received, I added some prints in the code to show the problem I am having.

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


 //define the Q element struct
 typedef struct _item{
        struct _item* next;
         struct _item* prev;
         int data;
} item;

 item * newItem(){

         item * node = malloc(sizeof(item));
         return node;
 }

 void initQueue(item ** head){
         *head = NULL; //Empty queue means head points to NULL
 }

 void addQueue(item ** head, item item_p){
         //create new item
         item * newIt = newItem();
         newIt = &item_p;
         printf("NewItem: %d\n\n", newIt->data);

         //if *head is NULL, make it point to item
         if(*head == NULL)
         {       
                 *head = newIt; //set head to address of item
                 newIt->next = *head;
                 printf("Again: %p\n\n",  *head);
         }
         //else the list is not empty, add item to end of list
         else    
         {       
                 item * iterate = NULL; 
                 iterate = *head;
                 printf("it: %p head: %p\n\n", iterate, *head);
                 /*while (iterate->next != *head)
                 {
                         iterate = iterate->next;
                 }
                 iterate->next = newIt;
                 newIt->next = *head;*/
         }
 }

Here is the .c file I wrote to test the functions:

#include "q.h"
#include <stdio.h>

int main ()
 {

 item  i1;
 i1.data = 1;

 item  i2;
 i2.data = 2;

 item  i3;
 i3.data = 3;

 item * headTemp;
 initQueue(&headTemp);

 addQueue(&headTemp, i1);
 printf("HEAD: %d\n", headTemp->data);
 addQueue(&headTemp, i2);
 printf("HEAD: %d\n", headTemp->data);

 addQueue(&headTemp, i3);


 return 0;
 }

And the output is:

NewItem: 1

Again: 0x7fff2252eb10

HEAD: 1
NewItem: 2

it: 0x7fff2252eb10 head: 0x7fff2252eb10

HEAD: 2
NewItem: 3

it: 0x7fff2252eb10 head: 0x7fff2252eb10

Segmentation fault

I created three items to insert into the queue. The first is placed in without issue. However I have problems when I insert a second item. The headTemp->data should remain the same no matter what I place into the queue, however it goes from 1 to 2 to 3, which is the data for all items I created. I'm not really sure what the problem is, and the answer may be staring me in the face. But I would really appreciate some help with this.

Cheers!

Answer 1

Your addQueue() function is not appropriate.

void addQueue(item ** head, item item_p){
28         //create new item
29         item * newIt = newItem();
30         newIt = &item_p;
31         printf("NewItem: %d\n\n", newIt->data);
32         
33         //if *head is NULL, make it point to item
34         if(*head == NULL)
35         {       
36                 *head = newIt; //set head to address of item
37                 newIt->next = *head;
38                 printf("Again: %p\n\n",  *head);
39         }

In this you do newItem() to get newly allocated node, but you again re-assign it to &itemp_p on line 30. This is not good, as you are not using allocated memory, but items variables i1, i2, i3 declared in main() .

Also, in newItem() set next and prev to NULL

17 item * newItem(){
18 
19         item * node = malloc(sizeof(item));
           if(node) { //You can use calloc too.
              node->next = NULL;
              node->prev = NULL;
           }
20         return node;
21 }

Answer 2

Thanks for posting paste-able code. Right out of the gate, this is wrong:

 item * newIt = newItem();
 newIt = &item_p;

this is an immediate memory leak. Worse the address your replacing it with is a by-value automatic variable. Therefore the address is going to be invalid to even evaluate , much less dereference, as soon as this function is finished.

Next, you need to prime your nodes with valid state for all member variables. How you do this is up to you, but the simplest way is in the node-creation code. To really do this properly, your node creation code should be a "factory" function. Ie it should take as parameters what is needed to initialize the node. So do this first:

item* newItem( int data )
{
    item * node = malloc(sizeof(item));
    if (item == NULL)
    {
        perror("failed to allocate node.");
        exit(EXIT_FAILURE);
    }

    node->data = data;
    node->next = node->prev = NULL;
    return node;
}

Once you have that solid, you can modify your addQueue to do this:

void addQueue(item** head, int data)
{
    item *prev = NULL;
    while (*head)
    {
        prev = *head;
        head = &prev->next;
    }

    *head = newItem(data);
    (*head)->prev = prev;
}

This code is still a ways off from being a deque. You need two pointers to do that, and the best place to keep them is in a separate struct, along with a count to make size-inquiries O(1). Properly done, insertion is O(1) in a full deque, but you'll get there eventually.

Anyway, an updated main appears below for testing everything made it in. Eventually you want a pop-functoin, etc.

int main()
{
    item *q = NULL;

    for (int i=1; i<=20; ++i)
        addQueue(&q, i);

    item *p = q;
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
    return 0;
}

Output

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20