打印 C 字符串时不需要的字符

Question

For the most part my code below does what I want. The only issue is it is printing extra unwanted non-ASCII characters in front of the string.

I tried printing the string inside the longestConsec() function and found that it already contains the unwanted characters so I know that the problem is in the function.

Additionally, I tried looping through res (using the length that I assigned to it with malloc() ) to set the characters to whitespace; this worked but I don't want leading and trailing whitespace and I don't want to write an algorithm to remove it if it's not necessary.

If I did something to cause these unwanted characters to appear then I would prefer to fix that than to work around by setting everything to whitespace and then trimming it.

Any help would be appreciated.

Output:

Expected Output:threefourthreefour
Output: ÉmthreefourÉmthreefour
Output with white space replacement:          threefour         threefour

Code:

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

char* longestConsec(char* strarr[], int n, int k)
{
    int i = 0;
    int longest = 0;
    int longestIndex = 0;
    for(; i < n; i++) {
        if(longest < strlen(strarr[i])) {
            longestIndex = i;
            longest = strlen(strarr[i]);
        }
    }
    //printf("%d", longestIndex);
    int length = 0;
    i = longestIndex;
    int j = 0;
    for(; i < n && j < k; i++, j++) {
        length += strlen(strarr[i]);
    }
    char* res = malloc(length * sizeof(char));
    int m = 0;
    for(; m < length; m++) {
        res[m] = ' ';
    }

    i = longestIndex;
    j = 0;

    //printf("%s", res);
    for(; i < n && j < k; i++, j++) {
        strcat(res, strarr[i]);
    }
    printf("%s", res);
    return res;
}



int main()
{
    char* strs[10] = {"One", "Two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"};
    printf("%s", longestConsec(strs, 10, 2));
    return 0;
}

Answer 1

the problem with the leading 'unexpected' characters is because the call to strcat() begins placing characters WHERE it encounters a NUL byte.

That could be anywhere,in memory (IE undefined behavior with out setting the NUL byte in the code.)

Rather than the loop that sets all the bytes in the allocated memory nor calling calloc() , a MUCH BETTER method would be to set the FIRST byte of the allocated memory to NUL IE

res[0] = '\0';

Then the following call(s) to strcat() will work correctly.

Answer 2

Valgrind shows this quite straightforwardly:

==19471== Invalid read of size 1
==19471==    at 0x4C2EAA4: strcat (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==19471==    by 0x108863: longestConsec (46557761.c:34)
==19471==    by 0x10892A: main (46557761.c:45)
==19471==  Address 0x51d5049 is 0 bytes after a block of size 9 alloc'd
==19471==    at 0x4C2BBEF: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==19471==    by 0x108805: longestConsec (46557761.c:23)
==19471==    by 0x10892A: main (46557761.c:45)

You have created an unterminated string with at least length characters in a block of size length you allocated. Appending will necessarily overrun the buffer, simply while looking for the end of the existing string.

Instead of writing length spaces, you should write a single NUL character, to form an empty string.

BTW, you should fix your compilation warnings (ensure you have at least -Wall -Wextra or equivalent).

---

Fixed code

#include <string.h>
#include <stdlib.h>

char *longestConsec(const char *strarr[], unsigned int n, unsigned int k)
{
    unsigned int longest = 0;
    unsigned int longestIndex = 0;

    for (unsigned int i = 0;  i < n;  ++i) {
        unsigned int len = strlen(strarr[i]);
        if (longest < len) {
            longestIndex = i;
            longest = len;
        }
    }

    unsigned int lastIndex = longestIndex + k;
    if (lastIndex > n) {
        lastIndex = n;
    }

    unsigned int length = 0;
    for (unsigned int i = longestIndex;  i < lastIndex;  ++i) {
        length += strlen(strarr[i]);
    }
    char *res = malloc(length + 1);
    res[0] = '\0';

    for (unsigned int i = longestIndex;  i < lastIndex;  ++i) {
        strcat(res, strarr[i]);
    }
    return res;
}


#include <stdio.h>
int main()
{
    char const *strs[10] = {"One", "Two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"};
    char *longest = longestConsec(strs, 10, 2);
    printf("%s\n", longest);
    free(longest);
    return 0;
}