String constants and strings created or manipulated by C library functions all set that terminating null character, '\0'. When you build your own strings, however, it’s easy to completely forget that null character. I know. I’ve done it.

A lot of safe coding practice in C deals with strings. From my books and courses, you’ve read that a string isn’t really a variable type in C; a string is a char array. The final character in the “string” array must be a null character, \0. That character’s appearance is how the C language (and just about every other programming language) spies the end of a string — unless you forget to add that character.

The following code builds a string and forgets to cap it with a null character:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char *alphabet;
    int a;

    alphabet = (char *)malloc( sizeof(char)*26);
    if( alphabet == NULL)
    {
        fprintf(stderr,"Memory allocation error.\n");
        exit(1);
    }

    for(a=0;a<26;a++)
        *(alphabet+a) = 'A'+a;

    printf("Here's your alphabet: %s\n",alphabet);

    return(0);
}

Storage space for the string is allocated by the malloc() function at Line 9. Only a 26-character buffer is created, one for each letter of the Latin alphabet. (No room for the null character!) And the array is built in Lines 16 and 17. Line 19 prints the result, which looks like this on my computer:

Here's your alphabet: ABCDEFGHIJKLMNOPQRSTUVWXYZ[?

Output on another system might look different. For example, you might be lucky and memory is populated with zero-value bytes so the output looks perfect, but the code is still wrong: The string lacks a terminating character and storage lacks room for that character. The array is still valid, and it could be used as an array of single char values, just not as a string.

To ensure that you’re working with a string and not just a collection of char variables waiting at a bus stop, cap the string with a null character, \0. This practice must be done any time you cobble together a string, which happens frequently in C.

Here is the improved code:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char *alphabet;
    int a;

    alphabet = (char *)malloc( sizeof(char)*26+1);
    if( alphabet == NULL)
    {
        fprintf(stderr,"Memory allocation error.\n");
        exit(1);
    }

    for(a=0;a<26;a++)
        *(alphabet+a) = 'A'+a;
    *(alphabet+a) = '\0';

    printf("Here's your alphabet: %s\n",alphabet);

    return(0);
}

In Line 9, I added a +1 inside the malloc() function. This format is a mnemonic to ensure that the null character is accounted for, and I (try to) do it in all my code. In fact, last week’s Lesson used the +1 in a realloc() statement that combines both strings.

Room for the null character must also be accounted for when you allocate a string array directly, as in alphabet[27].

At Line 18, the null character is appended to the end of the alphabet array. The alphabet+a math works because I know that the value of a was incremented one final time after the for loop stopped spinning; the loop’s terminating condition is a<26. Therefore, a must equal 26 after the for loop is done. At that position — alphabet+a or the 27th element of the array — the character \0 is set, terminating the string.

The code is now safe and the string will be handled properly elsewhere in the code because its null-terminated. The output is also consistent:

Here's your alphabet: ABCDEFGHIJKLMNOPQRSTUVWXYZ