Memory Management in C

Two things that really drive me crazy when coding in C are how to handle errors and memory management. I want to discuss memory management techniques.

When I first started working in C lifetimes ago, I didn't worry about memory allocation too much. I probably used fixed size allocation. In fact, the thought of having to use a malloc probably scared the pants off me. But malloc isn't the only way to allocate memory, is it? There's allocation that happens when you compile, and variable length arrays and alloca (which are nearly the same thing). Every time you need to allocate some memory or call a function, you need to think about these things. Who is going to allocate the memory -- the caller or the callee? Is it going to be on the stack or the heap? Who's going to free it? What kind of data structure will hold the memory? How do you deal with freeing the memory when there's an error?

The very first thing that you should know is what not to do. When you write a function and allocate some memory on the stack, do not ever keep a reference to that memory once the function goes out of scope.

char *foo(void)
{
    char b[]="hello world";
    return b;
}

That string is on the stack. When the function returns, you will have a pointer to memory that isn't yours. I had to do this a few times before I learned this, and it still tempts me. The trouble is, introductory texts on programming don't tell you these things. When you're learning a language that's close to the hardware, it's important to understand what's really going on. So, what are your options here? You could try this.

char *foo(void)
{
    char *b = malloc(sizeof(char)*(11+1));
    strcpy(b,"hello world");
    return b;
}

This memory is ours until the process quits or calls free on it. But now the caller needs to free it. It's also unsafe because I didn't check to see if malloc returned NULL. What if you need to allocate memory for multiple variables? You can't return multiple pointers, but you might try this.

void foo(int *a, char *b)
{
    *a = 10;
    strcpy(b,"hello world");
}

int main(void)
{
    int *a;
    char *b;
    
    if(!(a=malloc(sizeof(int))))
	return 1;
    if(!(b=malloc(sizeof(char)*(256))))
	return 1; //a will be freed on return
    foo(a,b);
    free(a); //just for demonstration
    free(b);
    return 0;
}

It seems less likely now that we would cause a memory leak since both malloc and free are both called in the same function. Of course, there is still the opportunity. Not to mention we have made the higher level code ugly. I would prefer to relegate the ugliness to the lower level functions and keep the high level ones clean since people might be reading and using them. You might clean it up a little.

int main(void)
{
    int a;
    char b[256];
    
    foo(&a,b);
    return 0;
}

Now that memory is on the stack. But we can still use it in foo as it remains valid until we exit from main. There is nothing wrong with this, but you have to be very careful about putting too much memory on the stack. You can request as much heap space as you want until the OS tells you there is no more available. You won't get a warning when you run out of stack space. And I believe programs are generally only given a relatively small amount by default. Not to mention you might accidentally assign a pointer to that memory and later try to access it when the function that allocated it has gone out of scope. Of course, you could always allocate the memory in the callee as I did before if you're really determined.

int foo(int **a, char **b)
{
    if(!(*a=malloc(sizeof(int))))
        return -1;
    if(!(*b=malloc(sizeof(char)*(11+1))))
        return -1;
    **a = 10;
    strcpy(*b,"hello world");
    return 0;
}

int main(void)
{
    int *a;
    char *b;
    
    foo(&a,&b);
    return 0;
}

What have I done here? If you declare a pointer in the calling function and allocate the memory there, you can access the memory that is being pointed to in the callee. But you can't change what the pointer is pointing to in the callee. This is what would happen if you tried.