When does a while loop stop when it reads a string in C?

Question

I'm trying to implement the strcpy function by myself. The original strcpy is part of the the string.h library.

char *strcpy(char *dest, const char *src)
{
    assert(dest != NULL && src != NULL);
    char *temp = dest;
    while (*src)    
    {
        *dest = *src;
        src++;
        dest++;
    }
    return temp;
}
            
void strcpyTest()
{
   char source[20] = "aaaaaa";
   char dest1[20] = "bbbbbbbbb";
   char desta[10]="abcd";
   puts(dest1); // bbbbbbbbb
   strcpy(dest1, source);
   puts(dest1); // aaaaaa
   strcpy(desta, source);
   puts(desta); // aaaaaa
   strcpy(desta, dest1);
   puts(desta); // aaaaaa
   strcpy(dest1, desta);
   puts(dest1); // aaaaaa
   strcpy(source, desta); 
   puts(source); // aaaaaa
}

As you can see, even the first call for the function with a longer dest than the src gives the right result although, by logic, it should give aaaaaabb and not aaaaaa:

   char source[20] = "aaaaaa";
   char dest1[20] = "bbbbbbbbb";
   strcpy(dest1, source);
   puts(dest1);
   /** aaaaaa **/

Why does my function work? I would guess that i'll have to manually add the /0 char in the end of *dest* after the while (*src)` will exit.

I mean the whole point of this while (*src) is to exit when it reaches the end of *src* which is the last char in the string which is /0. Therefore, I would guess i'll have to add this character to *dest* by myself but the code somehow works and copies the string without the manual addition of /0.

1. So my question is why and how it still works?

2. When I create a new array, lets say int *arr or char *arr, of 10, i.e char arr[10] or int arr[10] and I initialize only the 2 first indexes, what happens to the values that inside the rest of the indexes? Does they will be filled with zeros or garbage value or what?

Maybe my code works because it filled with zeros and that's why the while loop stops?

Answer 1

For starters you should select another name instead of strcpy.

Let's consider all the calls of your function step by step.

The variable source is declared like

char source[20] = "aaaa";

This declaration is equivalent to the following declaration

char source[20] = 
{ 
    'a', 'a', 'a', 'a', '\0', '\0', '\0', '\0', '\0', '\0', 
    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
};

because according to the C Standard elements of the array that were not explicitly initialized are implicitly initialized by zeroes.

The variable desta is declared like

char desta[10]="abcd";

This declaration is equivalent to the following declaration

char desta[10]= { 'a', 'b', 'c', 'd', '\0', '\0', '\0', '\0', '\0', '\0' };

So the first call

strcpy(desta, source);

just substitute four characters "abcd" for four characters "aaaa". The result array desta will contain a string because nether terminating zero is overwritten.

After this call

strcpy(desta, dest1);

the array desta will contain the string "bbbbbbbbb" because the last zero character of the array desta is not overwritten by this call.

This call

strcpy(dest1, desta);

in fact is not being changed the array dest1.

In this call

strcpy(source, desta);

as all the zero characters of the array source were not overwritten the array will contain a string.

You could get an unpredictable result if you called at first

strcpy(desta, dest1);

and then

strcpy(desta, source);

because your function does not append a terminating zero to the destination array.

Here is a demonstrative program.

#include <stdio.h>
#include <assert.h>

char * my_strcpy(char *dest, const char *src)
{
    assert(dest != NULL && src != NULL);
    char *temp = dest;
    while (*src)    
    {
        *dest = *src;
        src++;
        dest++;
    }
    return temp;
}

int main(void) 
{
    char source[20] = "aaaaaa";
    char dest1[20] = "bbbbbbbbb";
    char desta[10]="abcd";
    
    my_strcpy(desta, dest1);
    my_strcpy(desta, source);
    
    puts( desta );

    return 0;
}

The program output is

aaaaaabbb

That is the desta contains the string "aaaaaabbb" instead of the string aaaaaa.

The updated function could look the following way

char * strcpy(char *dest, const char *src)
{
    assert(dest != NULL && src != NULL);
    char *temp = dest;

    while ( ( *dest++ = *src++ ) );    

    return temp;
}

Answer 2

Correct that this function will not add a \0 to the end of the dest string. You will need to add a final \0 assignment to dest.

Why does it seem to work as-is? It "works" because your initialization of dest just happens to place a \0 character at the right point in the string. These cases are honestly "unlucky" as they hide all sorts of problems. Another case where this can happen is if you are running a debug build where memory is automatically set to 0 and therefore the final set bug is hidden.

So my question is why and how it still works?

If you initialize the first 2 values on an array, the rest are considered to be garbage, again exactly as you state. The exception to this would be if the array were "global" or "static". In these cases, the compiler will set them to 0 for you.

Answer 3

Your arrays are padded with zeros, which are equivalent to the null-terminator '\0'. When you initialize an array, any elements not explicitly set will be set the same way as if it were a static variable, which is to say the elements not explicitly initialized will be implicitly initialized to 0. So in this case, your strings just happen to have a null-terminator after you finished your copy because when you initialized the array, all of the values not explicitly set by your initializer were set to 0.

If you copy one a 4-character string into a buffer holding an 8-character string, you'll only see the first 4 characters changed in your destination string while leaving another 4 characters still there before you hit a null-terminator.

From the C11 Standard Working Draft 6.7.9 p21

If there are fewer initializers in a brace-enclosed list than there are elements or members of an aggregate, or fewer characters in a string literal used to initialize an array of known size than there are elements in the array, the remainder of the aggregate shall be initialized implicitly the same as objects that have static storage duration.

So according to the above passage, because you initialized some elements of the array, the elements that you did not explicitly initialize will be treated the same as if it were a static-storage duration object. So for the rules for statuc storage duration, we have 6.7.9 p10:

If an object that has automatic storage duration is not initialized explicitly, its value is indeterminate. If an object that has static or thread storage duration is not initialized explicitly, then:

— if it has pointer type, it is initialized to a null pointer;

— if it has arithmetic type, it is initialized to (positive or unsigned) zero;

— if it is an aggregate, every member is initialized (recursively) according to these rules, and any padding is initialized to zero bits;

— if it is a union, the first named member is initialized (recursively) according to these rules, and any padding is initialized to zero bits;

The above passage tells us that every member of the aggregate (an array in this case) will be initialized as per the element's rules, and in this case, they are of type char, which is considered an arithmetic type, which the rules states will be initialized to 0.