do i need to free local function pointer?

[adrian chung]

Im trying to understand more about pointers. Basically what im trying to do is to have a pointer passed into a function that accepts a pointer. Inside, i created a local pointer that points to the pointer passed into the function. I modified the value of the local pointer.

When this happens, it seems that it also modifies the value of the original y variable outside of the function. So if i'm assumingly correctly, that means unlike usual variables, local pointers directly links to pointers outside of the function.

Now based on the example, how should i free my pointers? I think i need to free my *ptr_y, but what about *x_ptr ? I can't free x_ptr since it might also free ptr_y accidentally?

#include <stdlib.h>
#include <stdio.h>
 
 
void myfunction(int *x)
{
    int *x_ptr = NULL;
 
    x_ptr = x;
 
    *x_ptr = 1111;
 
    printf("%myfunction local pointer is %d\r\n", *x_ptr);
 
 
}
 
int main(int argc, char* argv[])
{
 
    int y = 5;
    int *ptr_y;
 
    ptr_y = &y;
 
    printf("y starts with %d\r\n", y);
 
    myfunction(ptr_y);
 
    y = 6;
 
    myfunction(ptr_y);
 
    printf("at the end, y is %d\r\n", y);
    return 0;
}
 
 

[horace1]

on entry to myfunction() pointer x contains the address of y in main()

void myfunction(int *x)

so when you copy x to x_ptr

  x_ptr = x;
 

it contains the address of y therefore

    *x_ptr = 1111;
 

assigns the value 1111 to y

[Jason Mortmer]

DELETE pointers in the same scope/class in which they were created with the NEW keyword. You are already passing a pointer to the function and simply copying the reference. You need to free the pointer OUTSIDE the function:

// The pointer.
int *MyPointer = NULL;
 
// Create a NEW int in memory.
MyPointer = new int;
 
// Pass the pointer to the function.
myFunction(MyPointer);
 
// DELETE the pointer.
delete MyPointer;
 

Only free up memory that you have allocated to the heap manually (using 'new' operator).

In your example, you haven't created anything on the heap, you are just throwing pointers to stack variables around.

[adrian chung]

Im using C, not C++ so i guess there won't be any NEW or DELETE keyword.

Quote :
"
so when you copy x to x_ptr
x_ptr = x;

it contains the address of y.. "

If i free *ptr_y from outside of the function, will it automatically free *ptr_x? or is ptr_x going to point to the previous address ptr_y held even though ptr_y is freed?

[Jason Mortmer]

You have the wrong idea about how memory is manipulated in C/C++. First of all, in your program, you have no HEAP variables, so this information is useless in your program.

When you 'free' memory, a very low level operating system command is called. It tells the OS's memory management unit that the memory block that you freed can be used again. The pointers in your program are simply references, they have no physical tie-ins with the actual memory, they remain with the same value whether the memory has been freed or not. However, if you try using that pointer again, the memory might have been written over because the OS saw it as a free section of memory. If you 'copy' a pointer, you will have two pointers pointing to the same piece of memory.

 
// Create some new HEAP memory.
int *Mem = new int;
 
// Give another pointer reference to the memory created.
int *Mem2 = Mem;
 
// Delete the memory.
delete Mem2;
 

Mem AND Mem2 STILL store the old memory LOCATION but as YOU deleted it, you wont be silly enough to try and use it again :)

[adrian chung]

Jason, I'm almost understanding it there but..

what if your

int *Mem2 = Mem;
 

was declared inside a function? If we don't delete it, once we exited the function, there might not be a chance to delete it again.

and then put it in this scenario, we then delete Mem after we exit from the function.

at this stage, this would mean Mem2 is not cleaned since it used to point to Mem and we only deleted Mem.

[Jason Mortmer]

Like I said, Mem2 and Mem both point to the same block of memory. If you call delete on any of those, and ANY time, the memory will be freed. Doesn't matter if you make another pointer point to the same memory within a function, it's just so you have reference to an object inside the function rather than passing all of the memory to the function, you just pass the address of the allocated memory.

The following program is perfectly fine, causing no memory leaks:

 
int main()
{
   // An integer (4 bytes) is allocated in heap memory.
   int *Mem = new int;
 
   // Call a function, passing the POINTER, not the
   // actual int in memory, just a pointer to it.
   FunctionCall(Mem);
 
   // Good memory management says that you delete the
   // allocated memory in the same scope that it was
   // created.
   delete Mem;
 
   return 0;
}
 
// This function accepts a POINTER to some memory.
void FunctionCall(int *Mem)
{
   // This is just a pointer, a MEMORY ADDRESS.
   // NOTHING has been allocated on the heap when 
   // declaring this variable.
   int *Mem2;
 
   // Make the Mem2 POINTER POINT to the same block
   // of memory that Mem points to. Once again, 
   // NOTHING new has been allocated in heap memory.
   Mem2 = Mem;
 
   // Change something in the memory location by
   // de-referencing it with a '*'.
   *Mem2 = 1234;
 
   // At the end of this function, Mem and Mem2 will
   // both return 1234 when de-referenced as they both
   // point to the SAME block of memory.
 
   // NO deletion is done here as the memory was
   // allocated outside the function (this is what
   // the function assumes).
}
 

I couldn't have explained it in more depth right now, i hope this helps you.

[adrian chung]

thanks alot jason..that's really straight to the point esp with all the comments on the code...i really appreciate it!