Why this Array is assigning to non specified array?

Remember that a string in C needs space for a null terminator. If there is no space, printing will continue "to the next nul". Here is how your memory looks at initialization:

h  e  l  p \0 \0 \0 \0  d  u  d  e \0
^             ^         ^
a             b         c

When you read in a string ab in the location pointed to by b:

h  e  l  p \0  a  b \0  d  u  d  e \0
^              ^        ^
a              b        c

And all is well. But abc gives:

h  e  l  p \0  a  b  c \0  u  d  e \0
^              ^        ^
a              b        c

and when you print b you will get abc; printing c will get you nothing (first character is '\0').

Finally, with an input of abcd you get

h  e  l  p \0  a  b  c  d \0  d  e \0
^              ^        ^
a              b        c

And printing c will result in "d" - exactly as you are seeing.

In fact, the order in which things are stored in memory is not "defined", although usually the compiler will do something similar to the above. So while you know that you can't write to memory that isn't yours, you can't be sure what will happen when you do (as in your case). That is why it is called "undefined behavior". You can't rely on other compilers giving you the same result - or even the same compiler giving you the same result...

Make sense?

The solution, of course, is to allocate more space to b. That would result in more '\0' between b and c, and nothing gets overwritten.

edit - I did just realize that it seems that the order in which b and a are stored is backwards from how I just described it - because it's a, not c that is getting overwritten. Which shows that the compiler orders things as it jolly well pleases, and that I ought to wear my glasses when I write detailed answers. But the principle is exactly the same - so I will "leave the rest as an exercise for the student".

b[3] is an array of 3 characters. However the string abc is made of 4 characters, the last one being \0, indicating end of the string. So if you want be to be able to store abc, you need to declare at least an array of 4 characters, not 3

when you give abc as input your array b gets filled up(as it has only 3 places ) and has no space left for \0character. As a result when you try to print it out as a string .. it overflows and causes the error

For a string to be printable, it has to be of the following format: stringtext\0 but when you use up all the spaces in your array b you leave no space for \0 as a result when you print it , there is error

Also this statement is wrong in your code :

scanf("%s",&b);

it should be :

scanf("%s",b);

So what's really happening is you are going outside the end of your arrays and overwriting memory.

When you provide 'ab' as input to b, it works because b is large enough to store 'ab' and the \0 as others have mentioned.

When you provided 'abc' as input, b does not have enough space allocated to store abc and the null so it only stores 'abc' and then the null appears to get written to the first byte of the a array, which means it's just an empty string... or maybe it doesn't, this is the undefined part. Who knows what is stored outside your array. It just so happens you are probably getting lucky since those arrays you have defined are most likely in contiguous memory.

When you provide 'abcd' as input, the d and the null get written to the a array.

Many times in less-simple programs, you'll get a SEGV with programming errors like this.

This is simply one of the case of undefined behavior. b[3] can store a string of three characters (including \0), but when your input is abc it is of four character string and you can't store it in array b. You will get anything.

When you place "abc" into b[3], it's going past the end of the array. The abc string is four bytes since it has a nul terminator at the end.

Since it's undefined behaviour, anything can technically happen but what's actually happening is that the nul at the end of the string is overwriting the first character of the next variable in memory, rendering it an empty string.

Quickest solution is to ensure your character array are big enough to store all the characters plus the terminator:

char b[4] = "abc";

Or let the compiler handle it for this particular simple case:

char b[] = "abc";