Memory freed at the end of function?

Hi,

I was just wondering about this function I wrote:

Code:

/*Reverses a string*/
char *strrev(char *in_string) {
    char *out_string;
    int in_char,
        out_char;

    out_string = (char *) calloc(strlen(in_string), sizeof(char));
    
    in_char = strlen(in_string) - 1;
    
    for (out_char = 0; out_char < in_char+1; out_char ++) {
        out_string[out_char] = in_string[in_char - out_char];
    }
    
    return out_string;
}

I never free the memory pointed to by out_string, but I can't, because I have to return that. Am I screwing up somewhere, or is the memory freed when the function returns?

The memory is not freed when the function returns. Rather, the caller is responsible for freeing the memory, or passing this responsibility somewhere else.

That's one point of allocating memory dynamically - so that the object could outlive the function where it was created.

It might be also be possible to reverse the string in-place. If the caller doesn't care about keeping the original string, no extra memory allocation is necessary. But if he does, he'd have to allocate and make a copy of the string himself.

Yet another option would be also to accept the buffer where to write the output (except one should be aware that the algorithm would mess up the result, if the ranges overlap).

Thanks guys. I just came to the conclusion I should be freeing the memory in the calling function, but I thought I'd check.

Methinks too! anon has a good point about optimal memory utilization. Why use a buffer as long as the string when it can be reversed in situ by using just one temporary buffer; albeit it'll make your program computationally intensive ie resource tradeoffs.

Have the caller provide a second buffer to hold the reversed string. It's then the caller's responsibility to provide a buffer at least as big as the other one. The allocation and deallocation then occurs in the same function (if it's even done dynamically at all).