释放分配给函数的指针？

Question

When shall I free my unsigned char* if I need to pass the unsigned char* into a function? Example

void myFunction(unsigned char *request){
   // do I need to use free(request); here?
}  

 int main (){       
 // main code 

 unsigned char *request = NULL;
 // read from buffer and reallocate memory (using realloc & memcpy)
 myFunction(request); // I do not want to read or use "request" after this function call. 
 free(request); // is this ok? Or should this be inside myFunction also?

 return 0; 
 }

Answer 1

Use free() on something as soon as you're done using it. So for instance, you probably wouldn't do it inside myFunction() because you're probably still going to be interested in the value pointed at by request when you exit that function back to main .

Answer 2

Usually you have to free it where you have allocated it, and don't need more it. In This case you can do it in both places, but also, after freed set it to NULL, and next time when you'll try to free it, check for null

also you mai implement something like:

void FreeAndNull(void *request){
   if request <> NULL then 
     { free(request); request = NULL; }
}

Answer 3

You don't have to do this - but a good practice is to free things at the same level as you allocated them. Eg don't allocate something in a function and free it after it is returned. Because then the lifecycle of the memory is not clear to you months later when you look at the code again.

So it is much better to:

request = malloc();
doStuff( request );
free( request );

than the pattern you have. C++ helps you with this pattern by creating constructors and destructors. That is a constructor may actually allocate memory and essentially return it to you in the form of an object, but the compiler will automatically call the destructor for you freeing the memory.

So you can achieve something like the pattern you want with a much safer and more maintainable pattern if you wrap that request buffer in a class:

Request::Request() { mRequest = malloc(); }
Request::~Request() { if ( mRequest ) free( mRequest ); mRequest = NULL; }

...

{
    Request request;
    myFunction( request );
}

With this pattern you memory is cleaned up automatically. Safer and more maintainable.