Question

struct node {
    char name[20];
    int age;
    int height;
    node* next; // Pointer to the next node
};
node* startPTR = NULL; // global

void addNode_AT_END() {
    node *temp1;
    node *temp2;

    temp1 = new node;  

    cout << "Enter the name : ";
    cin  >> temp1->name;
    cout << endl << "Enter the age : ";
    cin  >> temp1->age;
    cout << endl << "Enter height : ";
    cin  >> temp1->height;

    temp1->next = NULL;

    if( startPTR == NULL) {
       startPTR = temp1; 
    }  else {
       temp2 = startPTR;

       while( temp2->next != NULL )
           temp2 = temp2->next;

       temp2->next = temp1;
    }
 }

In this snippet , when the function is called the third time , else part works. The address of the startPTR is assigned to the temp2. Now what does temp2->next contain when the condition is being checked in the while loop? (during third call) If you say it contains the address of the second node , please tell how does it know the address of the second node,because we had assigned the address of the second node to the first node during the second call to the function using the statement temp2->next = temp1 but because of it’s local scope we loose the address.

This is the way i am currently thinking.Please explain how the condition is checked during the third call to the function and how the linked list is being formed?

Answer 1

It’s only the pointer variables temp1 and temp2 that are of local scope. The actual linked-list nodes (of type struct node) are allocated on the heap via the call to new. Heap allocated data persists until it’s free’d via a call to delete.

This means that the line temp2->next = temp1 is storing the address of the new node that’s appended to the tail of the list, and this information will be available on subsequent calls to the function addNode_AT_END.

The code seems to have a variety of issues – you’re using global variables, unless there are subsequent calls to delete somewhere you have memory leaks, there’s already the std container class std::list that’s available…

Hope this helps.

EDIT: Regarding your comment – when you make a call new node you are constructing a node object on the heap. This object will available for use until a subsequent call to delete is made.

When you make the call temp2->next = temp1 the following is true:

1. temp2 points to the address in memory where the last node in the list is stored (this node would have been created by the call to new on the last iteration).
2. The value of the pointer variable temp1 is assigned as the next pointer for the last node in the list (the data “pointed to” by temp2). This means that the address is stored on the heap, not within the local temp2 pointer varaible.

When your function exits, yes the local pointer variables temp1 and temp2 go out of scope, but the heap allocated linked-list nodes are not destroyed – and this is where the addresses are stored.

EDIT: Second comment – in the else branch of the function, the pointer temp2 is initialised to point to the head of the list with the line temp2 = startPTR;

The next lines (the while loop) traverse the linked-list from the head node until the pointer temp2 points to the last node in the list (until temp2->next = NULL)

At this stage the new node is appended to the list, as discussed above.