'\0' is the null termination character. Without this you won't be able to know when the strings end. In your example

char foo[22] = { 'H', 'e', 'l', 'l', 'o' };

Is the same as

char foo[22] = { 'H', 'e', 'l', 'l', 'o', '\0', '\0', ..., '\0' };

With 17 times '\0'. When you Output the string you could have something like:

auto i = 0
do
{
    // Do smoething with foo[i++]
}
while('\0' != foo[i]);

The things that are called "C strings" will be null-terminated on any platform. That's how the standard C library functions determine the end of a string.

Within the C language, there's nothing stopping you from having an array of characters that doesn't end in a null. However you will have to use some other method to avoid running off the end of a string.

You can use c[i]= '\0' or simply c[i] = (char) 0.

The null/empty char is simply a value of zero, but can also be represented as a character with an escaped zero.

The null character '\0' and the newline character '\n' are two different character values, just as 'x' and 'y' are two different character values.

The null character, whose value is 0, is used to mark the end of a string, which is defined by the C standard as "a contiguous sequence of characters terminated by and including the first null character." For example, the strlen() function, which returns the length of a string, works by scanning through the sequence of characters until it finds the terminating null character. (The length of a string doesn't count the terminating '\0'; strlen("foo") and strlen("foo\0") both yield 3.)

The newline character, '\n', is used to denote the end of a line in a text file. Strings exist in memory while your program is running, and lines exist in a text file external to your program. You can read the contents of a line (in a text file) into a string (in memory); depending on how you read it, the resulting string may or may not include the terminating '\n'. Null characters do not normally occur in text files.

Note carefully that NULL is (a macro that expands to) a null pointer constant. Other than the fact that both a null pointer and a null character can be expressed as 0, they have very little to do with each other. Please do not use the term NULL to refer to the null character.

One minor thing: in C, a character constant such as 'x', '\0', or '\n' is actually of type int, not of type char. (C++ differs in this.) But they're almost always used to denote values of type char. For example, this:

char c;
...
c = '\0';

will store a null character value in c, the int value is implicitly converted from int to char. In most cases, you don't have to worry about this.

char and int are both integer types, and you can freely convert between them. The reasons for character constants being of type int are historical.

Also, I see you're using old-style (K&R) function definitions. Way back in 1989, the ANSI standard added a new way to define functions using prototypes (you actually use some in your code) -- and there have been two new versions of the C standard since then. Old-style function definitions are obsolescent, and should be avoided. This:

int func(x, y)
int x;
char *y;
{
    /* ... */
}

is an old-style definition. This:

int func(int x, char *y)
{
    /* ... */
}

is a definition that uses a prototype, and it's preferred. For one thing, it lets the compiler check that a call passes the correct number and types of arguments.

You'll probably have more questions after this. I strongly suggest you take a look at the comp.lang.c FAQ; it will probably answer most of them.

String literals like "Hello World!" are null-terminated, but char arrays are not automatically null terminated.

The general principle I've always taken is to be extra cautious and assign '\0' to the the end of the string unless that causes a performance problem. In those cases, I'm extra careful about which library functions I use.

A null byte is used in a char array to designate the end of a string. Functions that operate on strings such as strcpy, strcmp, and the %s format specifier for printf, will look for a null byte to find the end of a string.

You're not treating string as a string, but as just an array of char. So it doesn't matter whether or not a particular element of the array has the value 0 as you're not treating that value as special in any way. You're just printing the decimal value of each of the elements of the array.

In c, a string is not an intrinsic type. A C-string is the convention to have a one-dimensional array of characters which is terminated by a null-character, by a '\0'.

Using that knowledge it should be

 struct date{  char day[3];  char month[3];  char year[5];  

Otherwise scanf¹ won't be able to store the \0 within the array and it would be undefined behavior if you try to get 2 digit input (for day or month or 4 digit year by using %s format specifier) with it - because scanf will try to write it beyond the array and that would be Undefined Behaviour.

The scanf usage would be

if(scanf("%2s",current_date.day)!=1){
    fprintf(stderr,"Error in input\n");
    exit(EXIT_FAILURE);
}

The way you defined your structure - would give you 1 digit month, 1 digit day and 3 digit year if you store the corresponding \0 also. That is not what you want. In C strings are realized using nul terminated char array - scanf stores them. That's why in my case I have used %2s - so that the remaining space is there for storing \0.

¹ Here note one thing from reference under %s format specifier

matches a sequence of non-whitespace characters (a string) If width specifier is used, matches up to width or until the first whitespace character, whichever appears first. Always stores a null character in addition to the characters matched (so the argument array must have room for at least width+1 characters).

Note: As pointed by Simon Berthiaume in comment -

You can write string length like this: char year[4+1];, that way it is clear what the content size is intended to be. For example in this case it is 4 digit year that you wanted.