C return pointer question

Question

Hi, does this code

char *a()
{
    char *t = malloc(8);
    t[0] = 'a'; 
    t[1] = 'b';
    ...
    t[7] = 'h';
    return t;
}
int main(void)
{
    char *x = a();
    //do something with x 
    .....
    free(x);
    return 0;
}

have any potential problems since I allocate memory in a() and use that memory in main()??

Thanks.

Answer 1

No you won't have any problems explicitly because you allocated the function in a and use it in main.

Answer 2

As long as you remember to free the memory that x points to then you won't have any problems. By using malloc() you've allocated memory on the heap which is left alone when returning to the calling function.

Answer 3

First, a() is declared as returning void, but you attempt to return a char*. Change the signature to return a char*.

Second, your function is fine, but your example code has a memory leak because you never free the memory that the returned pointer points to.

Third, as gbrandt pointed out, you are not checking for success after the call to malloc. malloc can fail, and checking to see if it did is a good habit to get into.

---

Another way to accomplish this would be to pass a pointer to a pointer into a() instead, and then the caller has to create the pointer themselves before passing it to a(), but either way you still need to free the memory. To be honest, I would go with your approach over this in this case. There is no compelling reason to do it this way, just thought I would mention it.

void a(char **p)
{
    *p = malloc(8);
    if (*p)
    {
        **p[0] = 'a'; 
        **p[1] = 'b';
        ...
        **p[7] = 'h';
    }
}

int main(void)
{
    char *x;
    a(&x);
    //do something with x 
    .....
    free(x);
}

If this alternate approach confuses you, please let me know as I would be happy to provide an explanation (though, at the moment, I need to get back to work!)

Answer 4

Apart from having the wrong return type on a() (should be char * instead of void), the code doesn't have any problems.

Just be sure to free() the memory you allocated when you're done with it.

Answer 5

All good advice above. Small problems with the code, the big one is...

You are not checking for success in the malloc or after the function call. Never forget error handling.

Answer 6

Most of the answers here indicate that this isn't a problem, just remember to free() it later. This is technically true, but is really a problem. Any time you allocate memory in one scope and expect it to be freed in another, you are asking for a memory leak. People don't remember to free the memory. There is also the problem that the caller will have to know that you used malloc and not alloca() or new() or something else. If they call anything but the matched deallocation routine, the results are undefined.

In short, it is usually a mistake to allocate memory and pass it back to the caller.

It is better to expect the memory to be allocated by the caller because if they allocate it, they will remember to free it and to do so correctly.

Answer 7

Thanks. I just edited the code. I guess this time it should have no problem. Btw, in C, when a function finishes, does the compiler clear all variables (including array & pointer) in the stack?