Thread: Memory Leak??

Hello everybody
I would appreciate if someone can help me with the following

I am writing a program and debugging it, and suddenly when looking at the code I wrote, a doubt came to my mind: am I provoking a memory leak??

Here is the code

Code:

someType * Ptr=0;

for(i=0;i<3;i++)
{
    Ptr=0;    // POINT 1
    // Do something 
 
   do{
      Ptr=someFunction();
    } (while Ptr==0);
  
   // POINT 2
   // Do something else
}

As you can see first I have some pointer Ptr pointing to 0.
Then at the start of the loop (Point 1) I do that again.
Then I enter a do-while loop in which a function someFunction produces a pointer which is given to Ptr. This contains some data. The do-while is to make sure that someFunction produces an actual data and not 0.
Then I do something with the data, and go back to the start of the for loop.

to start again I point this Ptr to 0

and repeat everything again

My question is, between this point 2 and the point 1, am I losing the produced data and producing a Memory Leak???

Thanks in advance

Are you losing the data? Yes, you changed where Ptr points without saving the old value.

Are you causing a memory leak? Who knows. As laserlight pointed out, we need to know what someFunction does and returns.

A memory leak occurs when you allocate memory via malloc/calloc/realloc, and you dont' free() it. This includes failing to free memory allocated by a library or other code, which does a malloc under the hood.

You're not the only person who has suffered from actual, or worried about potential memory leaks. There are great tools like Valgrind (for Linux) that help you find memory leaks. I don't know what the Windows tools are, but I know several exist.

Thank you very much for your reply both of you.

Right now, someFunction is a function of this form

Code:

someType * someFunction(void)
{
   static someType returnValue;

// Here do some processing

   returnValue.firstComponent= someData1;
   returnValue.secondComponent = someData2;

  return &returnValue; 

}

Since this is a static variable I guess it stays even after leaving the function and since I am not using new or malloc, there is no risk for a memory leak. am I right?

Just for theoretical study, what would you do if you dont use a static variable? If I instantiate a variable inside the function, and then I do what I posted in my first post, that surely will give a memory leak, wont it?

If you "instantiate" a variable in someFunction (i.e. declare it as non-static; see example below) and return a pointer to it, you end up with undefined behavior. When the function returns, the memory that variable occupied becomes invalid (until used by something else), so the pointer you have to it points to invalid memory. Accessing invalid memory results in undefined behavior. In fact, modern compilers often catch this and warn you about it.

Code:

someType *someFunction(void)
{
    someType returnValue;

    returnValue.firstComponent = someData1;
    returnValue.firstComponent = someData1;

    return &returnValue;
}

However, if you declare a pointer inside someFunction, allocate memory to that and return the value, then that's not undefined behavior, but it would cause a memory leak.

Code:

someType *someFunction(void)
{
    someType * returnValue;
    ...
    return returnValue;  // No & here, returnValue is already a pointer.
}

At POINT 1 (Ptr=0, you overwrite the old value of Ptr (address of memory allocated in someFunction), so you no longer have that address to free the memory later. This is not a problem on the first iteration, Ptr doesn't point to allocated memory yet. Either free the memory at the end of the for loop, or save the address somewhere to be freed later.

Thank you very much both. That was a good explanation

So, just to be clear, now, by using a static variable, I am free of the memory leak problem and at the same time it is a valid piece of memory, is that correct?