链表的头在传递给函数时发生变化

Question

I've written a simple program including linked lists. When I try to display the linked list in the function it is created, it works alright; however, when I return to main and try to display it, it does not work properly.

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

#define LEN 20 
struct Node {
char word[LEN];
int count;
Node * next;
};

Node* build_linked_list (char array[][LEN], int N);
Node* make_ordered_copy (Node * head);
void print_list(Node * head);


int main()
{
#define NUMBER 10
char array[NUMBER][LEN]; // array which the words will be recorded
int N=6;
for(int a=0; a<N; ++a) strcpy(array[a], "test");
print_list(build_linked_list(array, N));
getchar();
return 0;
}

Node* build_linked_list (char array[][LEN], int N)
{
  Node ndArray[N];
  Node *head, *newnode;

  head = &ndArray[0];
  strcpy(head->word, array[0]); // writing the first element to the head
  head->count = 0;
  head->next = NULL;

  for(int a=1; a<N; ++a) // writing the elements in a linked list 
  {
    newnode = &ndArray[a];
    strcpy(newnode->word, array[a]); 
    newnode->count = 0;
    newnode->next = head; // first location now becomes second location
    head = newnode;
  }  

  print_list(head);
  printf("Previous values were shown in build_linked_list\n");

  return head;
}

void print_list(Node* head)
{
 Node* traverse;
 traverse = head;

 while(traverse) // while traverse is not NULL
 {
   printf("\"%s\" with the frequency of %d\n", traverse->word, traverse->count);
   traverse = traverse->next;
 }


 return;
}

When debugging in print_list function called from main, "traverse->word" shows the correct value at first but it does not print it right and then it changes to some another value.

Answer 1

The elements of ndArray are only valid within the scope of build_linked_list . Once the program exists that function, any access to those elements yields undefined behavior. You are building your linked list with those elements. Instead, you need to allocate memory for the nodes of your linked list on the heap, or you need to move the ndArray variable to the file scope so that it exists for the lifetime of your main method.

Answer 2

Inside build_linked_list you are declaring

Node ndArray[N];

which is the Node you are filling within that function. But when the execution ends the block of the build_linked_list function ndArray is deallocated therefore the pointer returned points to the memory previously allocated for ndArray but that now is no more occupied by that array.

The usual implementation of linked lists is done using the heap and dynamic memory allocation. When building your Node array you should write:

Node* ndArray = new ndArray[N];

But at this point I higly suggest you to read about Garbage collectors and how to properly manage dynamic memory, because this is a whole new topic which has been discussed over and over here on StackOverflow.

For this answer I'll just anticipate to you that when allocating with new or new[] (for malloc and free see the C reference) you should as well delete with delete or delete[] respectively. In this case, when you are done with a linked list or ndArray you should write:

delete[] ndArray;

to free the memory. Otherwise you'll have a memory leak.