Problem with char* variable malloc/free. Empty contents on recipient variable after using free

Question

I am working on a custom SD card data logger using the following function and struct:

char *filenameCreator(const char *prefix, const char *num, bool addExtension)
{
    char *filename = (char *)malloc(13 * sizeof(char));
    const char *uScore = "_";
    strcpy(filename, prefix);
    strcat(filename, uScore);
    strcat(filename, num);
    if (addExtension)
    {
        const char *ext = LOGFILE_EXTENSION;
        strcat(filename, ext);
    }
    delete[] num;
    return filename;
}

where the output will be saved on a variable of the following type:

struct FileInfo
{
    const char *fileName;
    double fileSize;
};

with FileInfo fileToDelete; and a global variable char* createdFilename = nullptr; to temporarily store the function's output.

The issue is that when using the functions as follows, fileToDelete.fileName is EMPTY:

createdFilename= filenameCreator("FILE", numericConverter(receivedIndexSATCOM), true);
fileToDelete.fileName = createdFilename;

free(createdFilename);    // seems to clear the contents of the variable where the filename was stored, namely, fileToDelete.fileName
createdFilename = nullptr;

I am trying to stick to the rules of freeing up memory used by malloc'd variables.

Please note that if I DON'T USE free(createdFilename), the code works fine and the fileName is created correctly. However, I am concerned about undefined behaviour or erratic responses.

Here is an example of a filename successfully created when NOT using free():

Do I invariably need to free the pointer after each use? Why the contents are empty even after assigning the contents to another variable?

EDIT:

Please, instead of downvoting my question, comment on what is wrong with my questions and I will try to improve it. Be mature.

Answer 1

What you have is called a "Dangling Pointer". You are trying to use a pointer that is pointing to memory that has been freed and doesn't contain what you think it does anymore.

This line of code in the filenameCreator function:

char *filename = (char *)malloc(13 * sizeof(char));

allocates a block of memory in the heap and saves a pointer to it. Later in the function you return that pointer.

return filename;

When you call this function:

createdFilename= filenameCreator("FILE", numericConverter(receivedIndexSATCOM), true);

You assign that pointer value to a new pointer. Now createdFilename points to this block of memory that you allocated in the function.

When you get to this line:

free(createdFilename);

That frees the block of memory that is being pointed to. This means that its contents can be destroyed, or left there, or used for something else. You've said with this line of code that you won't use it anymore.

If you try to use createdFilename later, it will still point to the same place in memory. But the stuff you had stored there has been freed. It is no longer there.

If it is your intention to keep using that file name, then don't free the memory until you are done using it. Sometimes that means the life of the program and you never call free.

It is important to free memory that you allocated, but only when you are done using it.