Why the string initialized with the too long initiializer would behave like this

Question

#include<stdio.h>

void main()
{
    int i;
    char str[4] = "f4dfkjfj";
    char str2[3] = "987";
    char str3[2] = {'j','j','\0'};

    //printf("%c\n",str[1]);
    //printf("%c\n",1[str]);

    puts(str);
    puts(str2);
    puts(str3);           
}

Output observation:

• Printing str2 prints the contents from both str2 and str.
• Printing str3 prints str3, str2 and str.

Why this behaviour while printing the not nul ended string, which is concatenated with strings previously defined until "\0" character is encountered by the puts() function (this function prints till it encounters a nul )?

(Note: I deliberately initialised them with too long initializer strings)

Answer 1

(Note: I deliberately initialised them with too long initializer strings)

Then you should be aware of the side-effects, too.

The problem with all your arrays are, they are not null-terminated, so they are not strings.

Quoting C11, chapter §7.1.1, Definitions of terms, (emphasis mine)

A string is a contiguous sequence of characters terminated by and including the first null character. [...]

Using them with string handling functions (like puts()) would invoke undefined behavior, as the functions, in search of the null-terminator, would go out of bound (i.e., outside allowed memory region) and cause the invalid memory access.

Quoting the standard again, chapter 7.21.7.9,

The puts function writes the string pointed to by s to the stream pointed to by stdout, and appends a new-line character to the output. The terminating null character is not written.

The expected argument is a string, which, none of the arguments in your code is.

That said, FWIW, for a hosted environment, the recommended signature of main() is int main(void), at least.

Answer 2

Initialization

  char str[4] = "f4dfkjfj";

as well as

  char str2[3] = "987";

and

  char str3[2] = {'j','j','\0'};

are incorrect, because expression char str[4] allocates 4 bytes for data, but data - "f4dfkjfj" requires 9 bytes - 8 bytes for visible characters and one more byte for '\0'.

UPDATE:

Lets consider the following example

#include<stdio.h>

void main()
{
    int i;
    char str[4] = "f4dfkjfj";
    char str2[3] = "987";
    printf("Address of str2 = %p and size is %d bytes\n", str2, sizeof(str2));
    printf("Addres     |  Data in memory\n");
    char * ptr;
    for (ptr = str2 - 2; ptr <= str2 + 5; ptr++)
    {
        printf("%p   | %c\n", ptr, *ptr);
    }
}

In my Visual Studio 2013 under Windows 7 I see the following:

But if I change char str2[3] = "987"; to char str2[4] = "987"; result will be

Try puts(str2) for char str2[4] = "987"; and you will see the difference.

Note: each time memory addresses (in the stack for local variables) are (can be) different, but data around allocated memory (changed or not) are more important.

Answer 3

These lines are constraint violations. The compiler should give an error message and the behaviour of the program is completely undefined:

char str[4] = "f4dfkjfj";
char str3[2] = {'j','j','\0'};

The constraint being violated is that there are too many initializers for the array. (C11 6.7.9/2)

However char str2[3] = "987"; is correct, there is a special case that when an array is initialized from a string literal, it is allowed to ignore the null terminator if there is no room in the array. (C11 6.7.9/14)

Going on to pass str2 to a function that expects a null-terminated string would cause undefined behaviour however.