Question

I’m not sure if this question has been asked before ( searched through SOF and couldn’t find an answer)

I wrote a LinkedList class and a function to reverse it.The function as follows,

    struct LinkedList::element* LinkedList::recurrsiveReverseList(element* head){
     element* tempList;
     if(head->next == NULL){
        return head;
     }else{
        tempList = recurrsiveReverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return tempList;        
    }
   }

here I am declaring a local pointer variable and making some changes to it and returning it back to the caller. In C++, when I declare a local variable inside a function the scope exists only inside the function. Now when I return the pointer from the function how does it work? I am able to understand the logic and get the result (luckily) but I am not able to completely understand the working here.

Can somebody clear my doubt?

Answer 1

The scope of tempList terminates when you exit the function but tempList is a pointer to a block of memory whose scope does not terminate there because it’s been undoubtedly allocated by new. Memory allocated in such a way is valid right up until the point you delete it, regardless of how many functions you go in to or out of.

By passing the pointer back to the caller, it preserves said pointer elsewhere, where you can use it.

A simple example:

static char *fn (void) {
    char *rv = new char[42];
    return rv;
}

int main (void) {
    char *x = fn();
    delete [] x;
    return 0;
}

In the code above, the scope of rv is limited to the fn function after it’s declared.

The scope of x is limited to the main function after it’s declared.

However the memory allocated by new comes into existence within fn and continues to exist after returning to main. The address of said memory, initially stored in rv, is transferred to x by the assignment of the fn return value to x.