为什么这个基本链表在 MacOS 上工作，但在 Linux 上出现段错误

Question

I have a linked list lib I use occasionally on MacOS and I just tried using it on Linux and I'm getting all sorts of problems. I've broken it down into a much simpler version to get to the problems. I've been able to find where the problems are with gdb , I just don't know why they're happening. It works fine on MacOs even with address sanitizer. I suspect I might be misusing the pointers here somehow.

here's my list structure:

struct node {
  int value;
  struct node *next;
};
typedef struct node node_t;

struct list {
  node_t *head;
};
typedef struct list list_t;

And the functions:

void list_init(list_t *l)
{
  l = malloc(sizeof(list_t));
  assert(l);
  l->head = NULL;
}

static node_t *new_node(int value)
{
  node_t *new = malloc(sizeof(node_t));
  assert(new);

  new->value = value;
  new->next = NULL;

  return new;
}

void push(list_t *l, int value)
{
  node_t *node = new_node(value);
  if (l->head == NULL) {
    l->head = node;
  } else {
    node->next = l->head;
    l->head = node;
  }
}

void print_list(list_t *l)
{
  node_t *tmp = l->head;
  while (tmp) {
    printf("%d\n", tmp->value);
    tmp = tmp->next;
  }
}

main function:

int main()
{
  list_t *l;

  list_init(l);
  push(l, 2);
  push(l, 4);
  push(l, 6);

  print_list(l);

  return 0;
}

gdb is telling me that the NULL check in the push function ( if (l->head == NULL) ) is causing the set fault. But it's also telling me that l->head is indeed NULL. If i remove that, the seg fault just happens in the next place wherever l->head is called.

If i instead I don't declare my list as a pointer...like this:

int main()
{
  list_t l;

  list_init(&l);
  push(&l, 2);
  push(&l, 4);
  push(&l, 6);

  print_list(&l);

  return 0;
}

It fixes the issue. However, it then makes it as far as the print_list function. It will print the list then print a couple more junk values and then seg fault.

I appreciate any help. And I know no memory is freed here. Just trying to keep the code small to fix the problem.

Answer 1

For example this function

void list_init(list_t *l)
{
  l = malloc(sizeof(list_t));
  assert(l);
  l->head = NULL;
}

does not make a sense because the function deals with a copy of the value the argument of the type list_t * .

So changing the copy in this statement

  l = malloc(sizeof(list_t));

does not influence on the original pointer used as an argument. So this function in fact invokes undefined behavior. It does not initialize a list.

So after calling the function as in this code snippet

list_t *l;

list_init(l);

the pointer l stays uninitialized and has an indeterminate value. On the other hand, the function produces a memory leak.

And nothing is changed in this code snippet

list_t l;

list_init(&l);

because within the function list_init after this statement

l = malloc(sizeof(list_t));

the function deals with a dynamically allocated object of the type list_t instead of the passed by reference object l declared in main.

To fix the problem define the function list_init like

void list_init(list_t *l)
{
    assert(l);
    l->head = NULL;
}

and call it like

list_t l;

list_init(&l);

The function push can be written simpler

int push( list_t *l, int value )
{
    node_t *node = new_node( value, l->head );
    int success = node != NULL;

    if ( success )
    {
        l->head = node;
    }

    return success;
}

Correspondingly the function new_node can be defined like

static node_t * new_node( int value, node_t *next )
{
    node_t *node = malloc( sizeof( node_t ) );

    if ( node != NULL )
    {
        node->value = value;
        node->next = next;
    }
  
    return node;
}

Answer 2

Your list_init can't possibly work. C is pass-by-value, so nothing that list_init does will have any effect on the pointer variable l in main() , which remains full of uninitialized garbage. You ought to get a compiler warning for it (enable -Wall .!).

You probably want to have list_init() return its pointer instead of trying to pass by reference, so:

list_t *list_init(void)
{
  list_t *l = malloc(sizeof(list_t));
  assert(l);
  l->head = NULL;
  return l;
}
//...
int main()
{
  list_t *l = list_init();
  // ...
}

Your second version is likewise broken because when list_init() assigns to its local variable l , it just loses the pointer it was passed, so again nothing that it does has any effect on the l in main . You do not need to allocate anything in this version since you are already passed a pointer to a valid list_t object. So if you want to write it this way, then you would simply want

void list_init(list_t *l)
{
  l->head = NULL;
}
// ...
int main()
{
  list_t l;
  list_init(&l);
  // ...
}