Potential memory leak?

Question

The following code resolves the problem of removing the duplicate characters in a string.

void removeDuplicatesEff(char *str) 
{
    if (!str)
        return;

    int len = strlen(str);
    if (len < 2)
        return;

    const int sz = (1<<CHAR_BIT); 
    bool hit[sz] = {false};

    int tail = 0;
    for (int i=0; i<len; ++i) 
    {
        if (!hit[str[i]]) 
        {
            str[tail] = str[i];
            ++tail;
            hit[str[i]] = true;
        }
    }

    str[tail] = 0;
}

After setting str[tail]=0 in the last step, if char *str does contain duplicate characters, its size will be smaller, i.e. tail. But I am wondering whether there is a memory leak here? It seems to me that, later, we cannot releasing all the spaces that is allocated to original char *str. Is this right? If so, how can we resolve it in such situations?

Answer 1

It seems to me that, later, we cannot releasing all the spaces that is allocated to original char *str. Is this right?

No. The length of a zero-terminated string is completely decoupled from the size of the allocated memory buffer, and the system treats it separately. As long as every allocation is followed by a symmetrical deallocation (e.g. there’s a free for every malloc operation), you’re safe.

But I am wondering whether there is a memory leak here?

Arguably, yes, this is still a leak since it (temporarily) uses more memory than required. However, that is usually not a problem since the memory gets released eventually. Except in very special circumstances, this would therefore not be considered a leak.

That said, the code is quite unconventional and definitely longer than necessary (it also assumes that CHAR_BIT == 8 but that’s another matter). For instance, you can initialise your flag array much easier, saving a loop:

bool hit[256] = {false};

And why is your loop going over the string one-based, and why is the first character handled separately?