如何为局部变量释放动态分配的内存？

Question

Sample program:

#include <stdio.h>
#include <malloc.h>

void f(int n) {
     char *val = (char *) malloc(12*sizeof(char));
     val = "feels....";

     printf("%s", val);

 //  free val;     // if enable, compile time error: expected ';' before 'val'   free val;   
 }

 int main()
 {
      f(1);

      return 0;
 }

Is it required to free the memory which is dynamically allocated ? if yes, how to.

Answer 1

Yes, you need to free the memory. But when you allocate memory for a string, the way to populate the string is not to assign a string to it as that replaces the memory you've allocated. Instead you're meant to use the function strcpy like this...

char *val = malloc(12*sizeof(char));
strcpy(val,"feels....");

printf("%s", val);
free(val);

Answer 2

Instead of this:

 char *val = (char *) malloc(12*sizeof(char));
 val = "feels....";  // val points now to the string literal ""feels...."
                     // discarding the value returned by malloc
 ...
 free(val);          // attempt to free the string literal which will
                     // result in undefined behaviour (most likely a crash)

you probably want this:

 char *val = malloc(12*sizeof(char));  // in C you don't cast the return value of malloc
 strcpy(val, "feels....");  // the string "feels...." will be copied into
                            // the allocated buffer
 ...
 free(val);          // free memory returned previously by malloc

Answer 3

The compilation problem is because free is a function, you need to put its argument in parentheses.

free(val);

The other problem is a memory leak.

Strings in C are really just pointers to (hopefully) blocks of memory containing char data. The end of the string is denoted by a char with value 0. The thing to remember is that your variable is simply a pointer like any other pointer. So...

 char *val = (char *) malloc(12*sizeof(char));

The above line dynamically allocates a block of memory and assigns a pointer to it to val .

 val = "feels....";

The above line assigns a pointer to a string literal to val overwriting the previous pointer that was in val . It has not touched, in any way, the block of memory that was malloc ed in the first line. Furthermore, you have lost any reference you had to the malloc ed block so it has leaked. There's no way to free it.

String literals are usually created at compile time and the memory they occupy will be part of the program. This means they haven't come from the heap (where malloc gets its memory from. This means, in turn, when you try to free a string literal, bad things happen. On modern architectures, the program text is protected from writes at the OS level so trying to free part of it will almost certainly crash your program.

As long as you do not want to change the content of the string, you do not need to malloc space to it. You can omit the malloc line (and the corresponding free ) and your program will still work.

f you do want to change the string, the easiest way to get a mutable copy of a string literal is to use strdup :

char *val = strdup("feels....");

// Do stuff with the string

free(val); // strdup strings need to be freed

strdup is a Posix function but not a C standard function so your platform might not have it. It's pretty simple to implement your own, though.

char* myStrDup(const char* thingToDup)
{
    char* ret = malloc(strlen(thingToDup) + 1); // strlen returns the length without the terminating nul. Hence add 1 to it to allocate
    strcpy(ret, thingToDup); // Copies the entire string including the terminating nul.
    return ret;
}