Output changes depending on the position of the function call in the program

Question

I am currently learning C. One of the things I want to do in order to get better is to mimic the "strcat" function from the header. In order to make a more precise copy I compare the output of my own function with the output of the original one. They use identical, but different char arrays. However, the output of my own function changes if it is called after the original one. Here are the two code variations:

In the first one the output of the original is "1234567890123456", as expected, and the output of my own is "123456789123456". I have found after several dozens of various checks: the '0' char disappears from the src[0] once it is passed to the function as a parameter:

int main()
{

    char dest[10] = "123456789";
    char src[70] = "0123456";
    printf ("Concatenate |%s| and |%s|\n", dest, src); 


    char dest1[10] = "123456789";
    char src1[70] = "0123456";
    printf ("Normal people do: %s\n", strcat(dest1, src1));    
    printf ("Your filthy code: %s\n",  ft_strcat(dest, src));


    return 0;
}

However, if I simply relocate the printf of my function like this:

int main()
{

    char dest[10] = "123456789";
    char src[70] = "0123456";
    printf ("Concatenate |%s| and |%s|\n", dest, src);     
    printf ("Your filthy code: %s\n",  ft_strcat(dest, src));


    char dest1[10] = "123456789";
    char src1[70] = "0123456";
    printf ("Normal people do: %s\n", strcat(dest1, src1));    
    return 0;
}

both functions will return "1234567890123456" as an output.

The question is: how is this possible? I am curious because these functions address two different sets of arrays and therefore should not affect one another. For some reason my function's behaviour varies depending on when it is called in the body of the int main().

Please notice, that I have intentedly made the dest[] array 10 chars big, as I want to mimic the behaviour of original "strcat" in unexpected situations as well. Although that is probably the core of the problem, and if I change it, the code works fine in both aforementioned cases. As I said, I am interested in the nature of the problem, not in the way to solve it.

I am not sure whether the text of my function is relevant for this issue, but here it is, just in case:

char *ft_strcat(char *dest, char *src)
{
    int dest_end;
    int src_count;

    dest_end = 0;
    src_count = 0;
    while (dest[dest_end])
        dest_end++;
    while (src[src_count])
    {
        dest[dest_end] = src[src_count];        
        src_count++;
        dest_end++;
    }
    dest[dest_end + 1] = '\0';
    return dest;
}

Thank you for any answers.

Answer 1

This is due to the memory overlapping .... because you are declaring the size of dest1[10] and dest[10] instead of declare these two array with larger length like this

char dest1[100];
char dest[100];

your problem will be solved.

Answer 2

char dest[10] = "123456789";
char src[70] = "0123456";
printf ("Your filthy code: %s\n",  ft_strcat(dest, src));

char dest1[10] = "123456789";
char src1[70] = "0123456";
printf ("Normal people do: %s\n", strcat(dest1, src1)); 

In both cases, using your own function ft_strcat(dest, src)) or strcat() either, you invoke undefined behavior because the char array´s pointed to by destination are not capable to hold the initialized string plus the appended strings pointed to by source. When writing beyond the bounds of an array, the behavior of the program is undefined.

---

Solution:

The arrays dest and dest1 need to have at least 18 elements in total, 10 for holding "0123456789", 7 for the appending "0123456" + 1 element for the terminating null character \0:

char dest[18] = "123456789";
char dest1[18] = "123456789";

char src[70] = "0123456";
char src1[70] = "0123456";

printf ("Your filthy code: %s\n",  ft_strcat(dest, src));
printf ("Normal people do: %s\n", strcat(dest1, src1));

---

Side notes:

1. The array scr1 is redundant, as it only serves for providing the appending string and it exactly equals with its content to the string in src. You can use src for the second appending process, too:

printf ("Normal people do: %s\n", strcat(dest1, src));

2. src and src1 hold each 70 elements, which is unnecessary. They both need only to have 8 elements, not 70:

src[8] = "0123456";
src1[8] = "0123456";

A more handy approach is to omit the amount of elements and let the compiler automatically detect the amount of elements required, which also ensures that you wan´t forget the null character in counting:

src[] = "0123456";
src1[] = "0123456";

3. As the pointer src nor its pointed object shall get modified inside of ft_strcat() declare src as char const * const src.

dest can be made const too, but without making it a pointer to const char: char * const dest.

You can also adapt the return type of ft_strcat(), regarding the pointer dest.

The result is:

char * const ft_strcat(char * const dest, char const * const src)