To delete or to free

Question

The C++ language has specific rules about how you must free the memory to which a pointer points. These rules require you to know how the memory was allocated in order to correctly free it.

For example,

int *p = new int();
std::free(p);

results in undefined behavior. (Reference)

In modern C++, we like to use smart pointers where possible, but sometimes we may want to use libraries or functions that allocate raw pointers. Suppose I want to use a function of the form:

char* NotMyFunction();

How do I properly manage the memory allocated by this function?

Answer 1

How do I properly manage the memory allocated by this function?

You read the documentation of that function and do what that documentation tells you to do and when to do it, assuming there is anything to be done in the first place. It is important to remember that not all pointers refer to dynamic memory.

Example: The specification of strdup says:

Returns a pointer to a null-terminated byte string, which is a duplicate of the string pointed to by str1. The returned pointer must be passed to free to avoid a memory leak.

If no documentation is available, you can read the source code to see what the function does, and act accordingly. If the source isn't available either, then you're in a spot of bother, and might need to invest in a crystal ball.

Excluding standard functions, C APIs which acquire resources such as dynamic memory and return a handle (pointer in the case of dynamic memory) typically provide a corresponding function to release the resource. Example: SDL_CreateWindow and SDL_DestroyWindow.

---

would it be correct for me to infer that you are saying the following? In general, if you are given a raw pointer in C++, it is impossible to guarantee correct memory management of this pointer.

It is unclear what you mean. If you know how to manage the memory, then you can do it correctly. If you don't know how to manage the memory (or whether it needs to be managed by you at all), then you need a way to find the knowledge. There is no reasonable way in C++ to write the program in a way that would figure out (through introspection) how and when memory should be freed.

The type char* itself tells nothing about how the memory should be dealt with. Even the value of the pointer tells you nothing beyond if it is null, then it doesn't point to an object. If the pointer is non-null, then it might point to an object.

Answer 2

int *p = new int();
std::free(p);

That is uncorrect, it should be:

int *p = new int;
delete p;

or

int *p =  (int*) malloc(sizeof(int));
free(p);

Regarding to char* NotMyFunction();, wherever and however you allocate your char*, do not forget to to free or delete it. Do not loose your pointer, you will need it to release the memory.

char *NotMyFunction()
{
char* s = new char[n];
...
return s;
}

later:

char* nmf = NotMyFunction();
...
delete[] mfc;

Answer 3

I do not have thorough enough knowledge of C++ to say for myself, but based on what user2079303 has written in their answer, it seems that the theoretical answer to this question is that it is impossible. However, in practice there are many ways to approach this issue.

---

1. Check the documentation

In most cases, if you're developing software that uses a library, it should have documentation that provides this information. If not, you may want to question whether or not the benefits of using this library really outweigh the costs.

2. Check the source code

If you have access to the source code, you should be able to find out how the memory in question is being allocated. This is most likely more difficult than option 1, but it gives you a definite answer, rather than an answer that someone else wrote (which really should be correct, but doesn't have to be).

3. Use valgrind

Valgrind is a debugging utility tool, not a tool for proving correctness (correct me if I'm wrong), but in the absence of direct access to the resources we need to answer this question, it can be very useful. We can experiment with the following program, where we imagine that in our application we may not have access to the body of MysteryFunctionOne and MysteryFunctionTwo:

#include <iostream>

int* MysteryFunctionOne() {
  return new int();
}

int* MysteryFunctionTwo() {
  return (int *) malloc(sizeof(int));
}

int main() {
  int* p1 = MysteryFunctionOne();
  int* p2 = MysteryFunctionTwo();

  std::cout << std::hex << p1 << std::endl << p2 << std::endl;

  // For illustrative purposes, suppose we free both pointers incorrectly
  free(p1);
  delete p2;

  return 0;
}

If we compile and run the above program with valgrind program_name, we receive two important error messages, the first of which is:

Mismatched free() / delete / delete []
   at 0x4C2EDEB: free (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
   by 0x400A2E: main (in <path/to/program>)
 Address 0x5ab6c80 is 0 bytes inside a block of size 4 alloc'd
   at 0x4C2E0EF: operator new(unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
   by 0x4009A3: MysteryFunctionOne() (in <path/to/program>)
   by 0x4009C8: main (in <path/to/program>)

This tells us that we have incorrectly used free in function main. The lower half of the error message even lets us know that operator new was used in MysteryFunctionOne(). Thus we know we need to delete the pointer returned by MysteryFunctionOne(), so we change

free(p1);

to

delete p1;

The second error message we receive is analogous, and from it we learn that we need to free(p2).

In this case, even without reading the source code or documentation, valgrind was able to guide us towards correct memory management. In general, this may not always be the case, but it is an option to consider in the absence of the source code or salient documentation.