如何释放一个函数从另一个函数动态分配的内存？

Question

In the C program I've attached, I've defined a separate function called push() to add a node to the front of a linked list. push() allocates memory for a node on the heap, but I cannot free the memory here because then the work done by push() will not be reflected in the caller ( main() ). So how can I free the concerned heap-allocated memory from inside main() ?

Any sort of help is appreciated. Thanks in advance.

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

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

/* Prototypes */
void push(struct node **headRef, int data);

int main(void)
{
    struct node *head, *tail, *current;
    int i;

    head = NULL;

    // Deal with the head node here, and set the tail pointer
    push(&head, 1);
    tail = head;        // tail and head now point to the same thing

    // Do all the other nodes using TAIL
    for (i = 2; i < 6; i++)
    {
        push(&(tail->next), i);     // add node at tail->next
        tail = tail->next;          // advance tail to point to last node
    }

    current = head;
    while (current)
    {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");

    return 0;
}

/*
 Takes a list and a data value.
 Creates a new link with the given data and pushes
 it onto the front of the list.
 The list is not passed in by its head pointer.
 Instead the list is passed in as a "reference" pointer
 to the head pointer -- this allows us
 to modify the caller's memory.
*/
void push(struct node **headRef, int data)
{
    struct node *newNode = malloc(sizeof(struct node));
    newNode->data = data;
    newNode->next = *headRef;   // The '*' to dereference back to the real head
    *headRef = newNode;         // ditto
}

Answer 1

You can free the allocated space in main like this -

struct node * tmp;
while(head){
    tmp = head;
    head = head->next; //this is to avoid loosing reference to next memory location
    free(tmp); 
}

Since you pass address of variable in push , therefore, this could be possible.