when will we use "free" in c

[homoon]

Hi All, when I use "free" pointer in C, I got Sigabrt.

char* output=malloc(8*sizeof(char));
output="abcdefg";
printf("%s", output);

free(output); //<----SIGABRT error

Another Question:
If we want to return a char pointer in a function, and I need to free the pointer, when I free the pointer, will it affect the return value?
for e.g.

char* tmp()
{
  char* output=malloc(8*sizeof(char));
  output="abcdefg";
  printf("%s", output);

  return output;
  free(output);
}

[Salem]

Well your first one was right, until you did this

> output="abcdefg";

So when you called free, it wasn't with the pointer returned by malloc.

Try using
strcpy(output,"abcdefg");

[rags_to_riches]

output="abcdefg";

That's not how you get a string into your allocated memory; you use strcpy. What you're doing there is allocating the memory, then abandoning it (leaking it) and changing the pointer to point to a string literal in read-only memory, which causes the fault when you try to free it (because it's read only).

[smokeyangel]

Another Question:
If we want to return a char pointer in a function, and I need to free the pointer, when I free the pointer, will it affect the return value?
for e.g.

char* tmp()
{
  char* output=malloc(8*sizeof(char));
  output="abcdefg";
  printf("%s", output);

  return output;
  free(output);
}

That free will have no effect because it is after the return, so it is unreachable. If you had this:

char* tmp()
{
  char* output=malloc(8*sizeof(char));
  strcpy(output, "abcdefg");
  printf("%s", output);

  free(output);
  return output;
}

Do not do this, it will cause problems. When you malloc, you get a chunk of memory that is "yours" until you free it. When you free it, the memory is considered available for allocation again.
This code snippet can blow up in your face, because free() does not change the value of the pointer. The pointer will still point to the string you copied in, even after you return. However that memory is now considered free and can be reused by a subsequent malloc. So it is wrong to do this but it probably won't fail straight away.

You should free() when you are finished with the pointer. The calling function can free it when it is not using it anymore.

[homoon]

thx all, you all solved my problem, many thanks!!!

[fnprintf]

I am a little late in the discussion but here is my understanding.

Once you use malloc(), you create a memory block that you must manage... or free. So when to use free()?

Within a function, you want to free() any memory that you will not use outside of the function. This will prevent memory leaks.

If you want to access the memory outside the function, you have to return a pointer to the memory, since you cannot return memory from a function.

BTW, I'm still learning, so I could be wrong?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char *tmp ()
{
  char *output = malloc (8 * sizeof (char));
  strcpy (output, "abcdefg");
  printf ("In  tmp(), char *output.\tAddress: %p\tContains: %s\n", output, output);
  /* free(output); Using free here, would basically be saying: I no longer need the memory which contains "abcdefg".  */
  return output;
}

int main ()
{
    char *string = tmp (); /* The pointer *string will point to the memory created with malloc() inside the tmp() function. */
    printf ("In main(), char *string.\tAddress: %p\tContains: %s\n", string, string); /* Access the memory here. */
    free (string); /* free() here since we are done with string. free() will free memory that was created with malloc() inside the tmp() function. */
    return 0;
}