Pass reference causing Segmentation fault

Question

I am trying creating a circular link list. When I try to add an element by passing the head pointer as a reference, it throws a segmentation fault. I noticed that the value of the head pointer is changing as soon as I call the Add element function. Code snippet:

struct Node {
    int data;
    struct Node *next;
};

int c = 1;
typedef struct Node node;
//node *head = NULL, *temp, *temp2, *z;
node *InitQueue(node *);
node *AddQueue(node *, int);
void DelQueue();
void display(node *);

void main()
{
    int ch;
    node *head = NULL;

    do {
        printf("1.Creation Q\n");
        printf("2.Insert element to Q\n");
        printf("3.Delete element\n");
        printf("4.Display Q\n");
        printf("5.Exit\n");
        printf("Enter your choice:\n");

        scanf("%d", &ch);
        switch (ch) {
        case 1:
            head = InitQueue(&head);
            printf("%d %p\n", head->data, head->next);
            break;

        case 2:
            printf("%d %p\n", head->data, head);
            int item;
            printf("Enter item\n");
            scanf("%d", &item);
            head = AddQueue(&head, item);
            break;

        case 3:
            DelQueue();
            break;

        case 4:
            display(&head);
            break;

        case 5:
            exit(0);
        }

    } while (ch != 5);

}

node *InitQueue(node * head)
{
    node *temp;
    temp = (node *) malloc(sizeof(node));
    printf("%p \n", temp);
    temp->next = temp;
    head = temp;
    printf("%p \n", head->next);
    return head;
}

node *AddQueue(node * head, int item)
{
    //InitQueue(&head);
    printf("%d %p\n", head->data, head);
    node *temp, *temp2;
    temp = head;
    temp2 = (node *) malloc(sizeof(node));
    //printf("Enter the data: \n");
    //scanf("%d", &temp2->data);
    temp2->data = item;

    while (temp->next != head) {
        temp = temp->next;
    }
    temp->next = temp2;
    temp->next = head;
    head = temp2;
    return head;
}

Please take the effort to format your code properly. It really helps understanding what is going on (and getting good answers on SO). — 5gon12eder, Sep 17 '15 at 00:16
no I haven't cause I know where the issue lies but unable to come to a conclusion what is changing the head pointer even before i try adding elements to it — user3155354, Sep 17 '15 at 00:17
if you know where the issue lies - fix it. otherwise continue using the debugger — pm100, Sep 17 '15 at 00:18
i understand that there is nothing called reference in C, but the initqueue function works fine but the not the addqueue function. — user3155354, Sep 17 '15 at 00:19
this code doesnt compile or you are ignoring warning. InitQueue takes a node * but you are passing a node ** to it (&head, head is a node *) — pm100, Sep 17 '15 at 00:23

score 4 · Accepted Answer · edited May 23 '17 at 11:44

Your problem is that you're passing the actual memory address of the variable head to your InitQueue and AddQueue functions (so that you can modify it inside the functions), but they're declared as:

node *InitQueue(node *);
node *AddQueue(node *, int);

Your functions are expecting node * and you passed node **.

When you do this:

head = InitQueue(&head);
...
AddQueue(&head, item);

1. Types are wrong. Your compiler complained about it and you ignored.
1. InitQueue only worked because you're returning something.
1. AddQueue doesn't work because it's expecting a pointer to node, not a pointer to pointer to node.

You should do:

void InitQueue(node **head)
{
    (*head) = malloc(sizeof(node));
    if (!(*head)) { /* error check */ }
    (*head)->next = (*head);
}

Now you call it the same way you were calling, but no need to return anything.

InitQueue(&head);

You can fix AddQueue by the same means.

Might Interest

score 0 · Answer 2 · answered Sep 19 '15 at 07:54

regarding this function, as an example of how to do the operation:

node *InitQueue(node * head)
{
    node *temp;
    temp = (node *) malloc(sizeof(node));
    printf("%p \n", temp);
    temp->next = temp;
    head = temp;
    printf("%p \n", head->next);
    return head;
}

There are a few problems with using that to initialize a linked list with the first entry.

Suggest:

//node *InitQueue(node * head) // passing 'head' here is useless
node *InitQueue( int data ) // use 'data' to fill in field on first node
{
    node *temp = NULL;

    // always check the returned value from malloc 
    // to assure the operation was successful
    // if not successful, handle the error
    if( NULL == (temp = malloc(sizeof(node)) ) )
    { // then malloc failed
        perror( "malloc for initial node failed" );
        exit( EXIT_FAILURE );
    }

    // implied else, malloc successful

    //printf("%p \n", temp);  // debug statement

    temp->data = data;
    temp->next = NULL;    // always set the 'link' to NULL so end of list can be found

    //head = temp;    // head is a copy on the stack, so has no effect on callers 'head'

    //printf("%p \n", head->next); // debug statement

    //return head;  // this is not set to point to the malloc'd node
    return temp;
}

Pass reference causing Segmentation fault

2 Answers2

Might Interest