Reference counting in C and memory allocated inside function

Question

I'm (attempting?) returning memory allocated inside a function.

Assuming there are no obvious problems with what I wrote here (and didn't test) how is the memory freed or not freed? I need to free(bob) later because he's on the heap not the stack, right?

I read something about reference counting in C in another accepted answer just now but I really really don't remember C having anything like a garbage collector.

char* strCat5000(char *fmt, ...)
{
  char buff[5000];
  char *ret_;
  va_list arg_ptr;
  va_start(arg_ptr, fmt);
  vsnprintf(buff, sizeof(buff), fmt, arg_ptr);
  va_end(arg_ptr);
  //ret_ = malloc((char*)(strlen(buff)+1)*sizeof(char)); //Allocated inside function
  ret_ = (char*)malloc((strlen(buff)+1)*sizeof(char)); //moved (char*) .. typo
  ret_ = strcpy(ret_,buff);
  return (ret_);
}
...
void findBob()
{
  char * bob;
  bob = strCat1000("Server is %s for %d seconds.", "on fire", 35329);
  printf("%s", bob);
  free(bob); //bob needs to be freed here or he'll leak when findBob ends???
}

Answer 1

Yes. You must "free Bob" in the findBob() method, since otherwise there will be no further notion of that particular piece of memory in your program => you will have a leak. So, in short: yes, that memory must be freed.

But then, just a side note: this kind of code is very "error prone". If you have a function allocating memory which the caller is supposed to free, it might be a good idea to have a freeBob() method or similar, which makes this purpose very obvious. It's usually a good idea to have malloc() and free() calls happen at the same level of abstraction. E.g. two functions in the same .c file might be a reasonable "abstraction level" in this case.

Answer 2

You're correct, if you return heap-allocated data from a function, it needs to be freed eventually (unless you need it until the program is finished, then you can depend on the fact that all memory is freed when the process exits).

Reference counting is a technique used to avoid freeing memory too soon. If you may copy a pointer into a number of variables, you don't want to free it while any of them are still using it. You allocate a structure that contains a refcount member. Every time you assign the pointer to another variable, you must increment the refcount, as well as decrement the refcount of whatever that variable was pointing to previously. When the refcount drops to 0, you can call free().

Wikipedia

Answer 3

To handle the above issue you have two approaches.

1st is what you are doing, that is free the bob after its use.Because nothing is automatic in c.

2nd is you can pass parameter to strCat1000 in which you want to store the result(let say it as store_var). In that case store_var will be on stack (it must be declared inside the findBob) and it will be automatically deallocated after findBob ends.

If you want freedom from free then make your code free from malloc.

Something like this could work:

void findBob()
{
  char store_var[1000];
  strCat1000(store_var,"Server is %s for %d seconds.", "on fire", 35329);
  ...

void strCat1000(char to_save[],char *fmt, ...)
{
  ret_ = strcpy(to_save,buff); //check for lengths also.
  ...

Answer 4

To make it real simple I wrote the following peace of code (c++). just run it and monitor your code memory usage using task manager.

#include "stdafx.h"
#include<iostream>
#include <conio.h>

using namespace std;
int * allocate(unsigned size)
{
    int * arr = new int[size];
    for(unsigned i=0;i<size;i++)
        arr[i] = i;
    return arr;
}
int main()
{
    int * p;

    p = allocate(1000000);
    getch(); // Here you still occupy the memory
    free(p); // here you free the memory you occupy in the function
    getch(); // here you should see that memory is freed before returning from the main
    return 0;
}