Freeing memory in C with basic trim example - c

Question

I'm trying to implement a trim function in C, and in doing so I'm using two sub-functions, ltrim and rtrim. I was wondering if I'm "leaking" memory somehow by calling malloc so much. If so, where should I be freeing the memory or altering how the malloc is called?
Ltrim:
char * rtrim(char * string) {
size_t slen = strlen(string);
char * modified_string = malloc(slen + 1);
strcpy(modified_string, string);
for (int i=slen-1; i>0 ;i--) {
if (string[i] == ' ' || string[i] == '\t')
modified_string[i] = '\0';
else
break;
}
return modified_string;
}
Rtrim:
char * ltrim(char * string) {
char c;
int start_index = -1;
char * modified_string = malloc(strlen(string) + 1);
for (int i=0; (c=string[i]) != '\0'; i++) {
if ((c == ' ' || c == '\t') && (start_index == -1)) {
;
} else {
if (start_index == -1) start_index = i;
modified_string[i - start_index] = c;
}
}
return modified_string;
}
Trim:
char * trim(char * string) {
char * string1 = ltrim(string);
char * string2 = rtrim(string1);
return string2;
}
Main:
int main(int argc, char *argv[]) {
char * new_str = " howlin ";
printf("Original: \"%s\" | RTrimmed: \"%s\"\n", new_str, rtrim(new_str));
printf("Original: \"%s\" | LTrimmed: \"%s\"\n", new_str, ltrim(new_str));
printf("Original: \"%s\" | Trimmed: \"%s\"\n", new_str, trim(new_str));
return 0;
}

Answer 1

Your functions aren't technically leaking memory, but they're making it really easy for the calling code to leak memory. Case in point: your sample main function leaked the buffers returned by the three calls to ltrim/rtrim, and your trim function leaked string1.
Instead, consider how these can be simplified. ltrim doesn't need to allocate memory at all. It can simply return a pointer to the first non-space character in the input string. rtrim isn't so easy, though.
One way to avoid the memory problems entirely is to have the functions modify the input string. Your output is never longer than the input, so you'll always have enough buffer available. rtrim would simply replace the first whitespace character at the end of the string with '\0', and ltrim would memmove() using a pointer to the first non-whitespace character. Modifying the strings in place means that the caller knows that they're responsible for making copies, allocating buffers, etc. and makes it harder to accidentally leak memory.

Answer 2

If so, where should I be freeing the memory or altering how the malloc is called?
Consider re-architecting your helper functions ltrim(), rtrim() without malloc() and let the calling code handle allocations.
// Return beginning of trimmed string.
const char *ltrim(const char * string) {
while (isspace((unsigned char) *string) {
string++;
}
return string;
}
// Return end of "trimmed" string.
const char *rtrim(const char * string) {
// find first non-space
const char *non_space = string;
while (isspace((unsigned char) **non_space) {
*non_space++;
}
if (*non_space) {
// Quickly go to the null character.
string = non_space + strlen(*non_space);
// While the character to the "left" is a space, backup.
// Here we know there is a non-white-space somewhere to the left,
// so loop will end with only a `isspace()` test.
while (isspace((unsigned char) string[-1]) {
string--;
}
}
return string;
}
Now armed with these helper functions ....
char * trim_alloc(const char * string) {
string = ltrim(string);
const char *end = rtrim(string);
size_t length = end - string;
char *copy = malloc(length + 1);
if (copy) {
memcpy(copy, string, length);
copy[length] = '\0';
}
return copy;
}
Was is speedy about rtrim is that each of its 3 loops (while, strlen, while) are each only testing for one condition and not 2 like "isspace && not null_character". This approach works best with sizable strings with a small amount of right trimming.