C-Style Strings and Null Terminators

A C style string is really just a regular character array terminated with a special character called the null terminator.

This terminator is zero valued and can be represented as '\0'.

Anything that treats an array as a string will keep reading until it hits this terminator.

It's important that the character array being used as a C style string has space for both the visible characters and for the null terminator, '\0'.

For instance, the visible characters "Hello" will occupy five positions of the character array. The character array needs to have space for six positions, because the sixth position must be reserved for the null terminator.

#include <iostream>

int main()
{
    char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

    std::cout << greeting << '\n';

    return 0;
}

When std::cout reads the character array, it will start at index 0 and continue reading until it sees the null terminator, at which point it will stop printing, but not before.

If the terminator is forgotten, the character array is not properly null terminated, and when you send it to std::cout, it may continue writing beyond the boundaries of the array, with results that are (in the most technical of terms) undefined.

A more convenient way to create a C style string than actually using \0 is to initialize an array of characters using string literals.

#include <iostream>

int main()
{
    char greeting[] = "Hello";

    std::cout << greeting << '\n';

    return 0;
}

A character array initialized this way actually has a "hidden" null terminator. So, a string literal of "Hello" is actually stored in six positions within the character array, including the terminator (even though the terminator isn't usually visible or printed in code, except when treated as an integer or character literal itself).

The compiler will create a character array capable of storing those five characters plus the null terminator (thus making the array six characters long).

If we need to modify a C style string, a character can simply be replaced using array indexing in square brackets. Modifying one of the visible characters in the string won't change the terminator, unless we overwrite it.

#include <iostream>

int main()
{
    char word[] = "stack";
    word[0] = 'S';

    std::cout << word << '\n';

    return 0;
}

However, so long as there is a null terminator character following the last logical character in the string, we are free to change any characters before the terminator that we want.

A C style string has no way of storing how many characters are inside it. Any function that has to manipulate a C style string has to start at the first character and move through the array until it finds the null terminator '\0'.

Therefore, it is crucial that the terminator character stays in the correct place and is actually the terminator! Otherwise, if you lose the terminator or accidentally move it further into the array, functions reading the string will continue into and read whatever comes after the misplaced terminator.

What we often forget to do when using C style strings is to reserve space for the terminator. An array that has to store 5 character letters would normally require 5 positions; however, we must remember to include one additional space position for the null terminator.

Therefore, instead of 5 positions, an array that stores the characters 'H', 'e', 'l', 'l', 'o' will need 6 positions in order to store the string "Hello\0".

Failing to do this will cause the character array to not properly "hold" the C style string, and any function trying to read the array will do so up until it hits a zero and will be treating whatever comes beyond the array as belonging to it as well, which would be considered undefined.

#include <iostream>

int main()
{
    char word[] = "stack";
    word[0] = 'S';

    std::cout << word << '\n';

    return 0;
}

#include <iostream>

int main()
{
    char word[] = "frame";
    word[0] = 'F';

    std::cout << word << '\n';

    return 0;
}

Frame