How to set struct pointer to NULL with function

Question

I am new to C. I set up a linked list like this:

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

#define len(array) (sizeof(array) / sizeof(array[0]))

#define true 1
#define false 0

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

typedef struct node node;

node* initNode(void){
    node* headNode;
    headNode = (node *)malloc(sizeof(node));
    headNode -> next = NULL;
    return headNode;
}

node* create(int* array, int length){
    node* newNode;
    node* lastNode;
    node* headNode = initNode();
    newNode = (node *)malloc(sizeof(node));
    headNode -> data = array[0];
    int arrayLength = 1;
    int hasSetHead = false;
    while(arrayLength < length){
        if (! hasSetHead){
            lastNode = headNode;
            hasSetHead = true;
        }
        memset(newNode, 0, sizeof(node));
        newNode -> data = array[arrayLength];
        newNode -> next = NULL;
        lastNode -> next = newNode;
        lastNode = newNode;
        newNode = (node *)malloc(sizeof(node));
        if (newNode == NULL) exit(0);
        arrayLength++;
    }
    return headNode;
}

void clear(node* headNode){
    node* nextNode;
    if (headNode == NULL) return;
    while (headNode -> next != NULL){
        nextNode = headNode -> next;
        free(headNode);
        headNode = nextNode;
    }
    *headNode = NULL;
}

int main(void){
    int array[] = {1,2,3,4,5,6,7};
    int length = len(array);
    node* list = create(array, length);
    clear(list);
    system("pause");
    return true;
}

I want to clear my struct by use clear(struct pointer). But in last line of clear(), I got this error:

error: incompatible types in assignment

What should I do? Thank you! And please forget my poor English.

Thanks！ @Marievi I've changed code like this:

headNode = NULL;

But when I want to print the linked list. It seems broken, here is my code:

void clear(node* headNode){
    node* nextNode;
    if (headNode == NULL) return;
    while (headNode -> next != NULL){
        nextNode = headNode -> next;
        free(headNode);
        headNode = nextNode;
    }
    *headNode = NULL;
}

When I called this function, it seems leak.

never cast results from malloc. See - http://stackoverflow.com/q/605845/5994074 — GAURANG VYAS, May 15 '17 at 13:05
Thanks! I learned it. But it seems didn't solve this problem. — 桂小方, May 15 '17 at 13:15
That was related to your problem, but a practice that should be followed. Just go through the link. — GAURANG VYAS, May 15 '17 at 13:17

score 1 · Answer 1 · edited May 23 '17 at 11:55

1

Change line :

*headNode = NULL;

to :

headNode = NULL;

and the error will disappear.

Also, do not cast the result of malloc and always check if malloc was successful.

edited May 23 '17 at 11:55

Community

1
1

answered May 15 '17 at 13:08

Marievi

4,951
1
16
33

Can we use `free(headNode)`. ? – GAURANG VYAS May 15 '17 at 13:09
@GAURANGVYAS of course, as it is a pointer which you dynamically allocated. – Marievi May 15 '17 at 13:09
One more question, here the OP wants to clear the whole list, so is it necessary to free every element in the list or only he head pointer? – GAURANG VYAS May 15 '17 at 13:11
@GAURANGVYAS when clearing a list, you are supposed to free all the elements you allocated. – Marievi May 15 '17 at 13:11
@桂小方 This was a question about compiling your code. You could edit your question or ask a new one if you are facing a different problem now. – Marievi May 15 '17 at 13:14
@Marievi Thanks, I've changed question now. – 桂小方 May 15 '17 at 13:21
@Marievi This answer is partially wrong. Correct or delete it. `headNode = NULL;` at the end of `clear` is a NOP. You can just remove it. – Jabberwocky May 15 '17 at 13:25

score 1 · Answer 2 · answered May 15 '17 at 13:28

Given headNode declared in your function as

node* headNode

, which is equivalent to

struct node *headNode

because of the in-scope typedef for type node. The problematic assignment

*headNode = NULL;

is attempting to assign the value NULL, a null pointer constant of type void *, to the object designated by *headNode, which is a struct node. You cannot assign a pointer value to an object of a structure type, which is what the error tells you.

You could assign NULL to headNode itself ...

headNode = NULL;

... as in fact another answer observes, but although the compiler will accept that, it will not have the effect you're after, because the headNode function parameter is local to the function. Its value is always a copy of the (pointer) value of its argument, and changes to the local copy do not affect the caller's original argument.

If you want the caller's copy to be changed then you have two main choices:

Return the modified value (NULL) and let the caller assign it to the original variable if it wishes to do so, or
Instead of passing the head pointer itself, pass a pointer to the variable containing the head pointer (of type node **).

Both alternatives will require changes in the caller; the latter will also require further changes to the function implementation.

Through your analysis, I understand its operating principle, very grateful！ — 桂小方, May 15 '17 at 13:55

score 1 · Accepted Answer · answered May 15 '17 at 13:33

This line (after the '*' removal) does exactly nothing as it only changes the local headNode parameter ( and 100% will be removed completely by the compiler)

 headNode = NULL;

If you want to assign NULL to the higher level pointer you need to pass node **headnode to this function or make it node *:. 1.

void clear(node** headNode){
    node* nextNode;
    if (*headNode == NULL) return;
    while (*headNode -> next != NULL){
        nextNode = *headNode -> next;
        free(*headNode);
        *headNode = nextNode;
    }
    *headNode = NULL;
}

and the call

 clear(&list);

or better

node *clear(node* headNode){
    node* nextNode;
    if (headNode == NULL) return;
    while (headNode -> next != NULL){
        nextNode = headNode -> next;
        free(headNode);
        headNode = nextNode;
    }
    return NULL;
}

and the call :

list = clear(list);

The first example does not compile, and both examples still do not free the last element of the list. — Jabberwocky, May 15 '17 at 13:54
@Michael Walz he did not ask about his algorithm, only about the language. — 0___________, May 15 '17 at 16:34

Jabberwocky · Answer 4 · 2017-05-15T13:51:35.403

0

The clear function is overly complicated and wrong. It doesn't free the last element.

This is correct:

void clear(node* headNode) {
  node* nextNode;

  while (headNode != NULL) {
    nextNode = headNode->next;
    free(headNode);
    headNode = nextNode;
  }
}

And if you want the clear function to set it's argument to NULL:

you need this:

void clear(node** headNode) {
  node* nextNode;

  while (*headNode != NULL) {
    nextNode = (*headNode)->next;
    free(*headNode);
    *headNode = nextNode;
  }

  *headNode = NULL;
}

and call it like this

clear(&list);
// now list is NULL

edited May 15 '17 at 13:51

answered May 15 '17 at 13:31

Jabberwocky

48,281
17
65
115

Thanks, your function also help me a lot~ – 桂小方 May 15 '17 at 13:53

How to set struct pointer to NULL with function

4 Answers4