链表的头节点传递到另一个函数，在此将其分配给函数中的本地节点。 为什么没有错误？

Question

"a"is the head node of a linked list. The memory for all the nodes is allocated thru malloc. After building the list (10 20 30 40) I am passing it to another function where I am assigning it to a node "current" which is declared locally and no malloc is done. Yet I am able to traverse the entire list correctly. Is "current" accessing the linked list in heap memory?

void main()
{
    struct node* a = (struct node*) malloc (sizeof(struct node));
    struct node* temp = (struct node*) malloc (sizeof(struct node));


    a->data = 10;
    temp->data = 20;
    a->next = temp;

    temp = (struct node*) malloc (sizeof(struct node));
    temp->data =25;


    temp = (struct node*) malloc (sizeof(struct node));
    temp->data = 30;
    a->next->next = temp;


    temp = (struct node*) malloc (sizeof(struct node));
    temp->data = 40;
    a->next->next->next = temp;

    a->next->next->next->next = NULL;

    printlist(a);

}


void printlist(struct node* head)
{
    struct node* current = head;
    while (current != NULL)
    {
        printf("%d ",current->data);
        current = current->next;
    }
}

Answer 1

The value of a pointer variable is the address of where it's pointing. This value can be copied and assigned to other variables, just like any other non-pointer variables.

When you pass a to the printlist function, the pointer is copied to the local variable head , and in turn copied to the current variable. Now you have three pointers ( a in the main function, and head and current in the printlist function), all pointing to the same location.

Answer 2

This is pretty straightforward, current is a pointer and you gave it whatever was stored in 'a' which is address of a head node. It doesn't matter that current is declared locally and of course you don't need to use malloc since you're not creating a new node. the variable current itself will be released you leave the function. To explain it in the code:

void printlist(struct node* head)
{
    printf("%p\n", head); //head has the memory address of first node
    struct node* current = head; //you created a pointer (struct node pointer) 
    //and gave it the address of the first node (you didn't create a new node
    //so there is no need for malloc)
    //size of current is size of a pointer and not a struct node
    printf("current: %p\n", current); //this will print that same address
    // which is first node address 
    while (current != NULL)
    {
        printf("%d ",current->data);
        //notice you're not using 'current.next' which would have been 
        //the case if current was local node. instead you're accessing head.
        current = current->next; 
    }
}

Answer 3

A pointer is basically the address in memory that stores that variable's value.

No matter what function you are using it from, if the variable is still in the heap, it can be accessed by that address.

Since your node also refers to the other elements of the list using a pointer (ie an address), then you get the entire list, no matter where you accessing it from.

Answer 4

You are passing a pointer which is the address to the head of the link list. Inside the function you are assigning current node to the head pointer which is a location in heap. So you are able to traverse through it.