Have I created a memory leak in this function? - c

Question

Trying to improve my C skills. This program should take a string and strip it of whitespace.
I'm aware I've made two calls to malloc but have only called free once. Have I thus got some unfreed memory somewhere, or because I assign the original pointer to the new memory, does it all vanish in the one free call I do make?
Thanks!
static void foo() {
char *string_to_change = malloc(sizeof(char) * 256);
strcpy(string_to_change, "my test");
printf("Before: %s\n", string_to_change); // "my test"
strip_whitespace(&string_to_change);
printf("After: %s\n", string_to_change); // "mytest"
free(string_to_change);
}
static void strip_whitespace(char **ptr) {
char *res = malloc(strlen(*ptr));
if (res == NULL)
exit_with_error(NULL_POINTER);
int current_pos = 0;
for (int i = 0; i < strlen(*ptr); i++) {
if (((*ptr)[i] == ' ') || ((*ptr)[i] == '\n' && ((*ptr)[i-1] == '\n' || (*ptr)[i+1] == '\0'))) {
continue;
}
res[current_pos] = (*ptr)[i];
current_pos++;
}
res[current_pos] = '\0';
*ptr = res;
}

Answer 1

You have a leak here:
*ptr = res;
Prior to this line, *ptr points to an allocated block of memory. You then assign to it the starting address of another allocated block, meaning the original pointer is lost. You should free right before this line:
free(*ptr);
*ptr = res;
Also, this allocation is potentially too little:
char *res = malloc(strlen(*ptr));
If *ptr contains no spaces to strip, res won't have enough memory to hold the terminating null byte. You'll need to add 1 to this.
char *res = malloc(strlen(*ptr) + 1);

Answer 2

KISS principle means we should write code as simple as possible, not as complex as possible. That is:
Don't mix up allocation and algorithm in a single unholy mess. Use caller allocation if possible.
Don't use dynamic allocation unless there's an obvious need for it.
It's usually a good idea to regard strings as "immutable" and not make in-place modifications to them unless there's specific requirements for that.
Avoid pointer-to-pointer and weird arithmetic on pointer-to-pointers.
The presence of continue in C programs is almost a dead certain indication of a needlessly complex loop.
Don't re-invent the wheel. There's ctype.h.
If we are to implement this with caller allocation, the code boils down to something compact and easy to read like:
void strip_spaces (char* dst, const char* src)
{
while(*src != '\0')
{
if(!isspace(*src))
{
*dst = *src;
dst++;
}
src++;
}
*dst = '\0';
}
Complete program:
#include <ctype.h>
#include <stdio.h>
void strip_spaces (char* dst, const char* src)
{
while(*src != '\0')
{
if(!isspace(*src)) // if not string
{
*dst = *src; // then copy
dst++;
}
src++;
}
*dst = '\0';
}
int main (void)
{
char str[] = " weird \n\r string contain ing spac\tes\n";
char stripped[128];
strip_spaces(stripped, str);
puts(stripped);
}

Answer 3

Indeed, there is a memory leak inside your code.
Let's say your first call to malloc allocate memory at address 0x0010 and your second call allocate memory at address 0x0100. Your free call will effectively free the memory at address string_to_change which is 0x0100 but nothing tells the compiler to free the memory at 0x0010.
Usually, you really have to have as many free calls as malloc calls.