C arrays, decay, and NUL-terminated strings.

Arrays, lists, and vectors showed that a C array is a fixed block of elements with no stored length. A declaration decides what is in that block at the start.

int visitors[6] = {40, 55, 31}; makes 6 ints. The values in braces fill the first elements, and every element without a value is 0. When the brackets are empty, as in int hours[] = {9, 10, 11};, the number of values sets the size: 3.

A char array can be filled from a string literal, text in double quotes. A string literal always ends with the null character '\0', a byte with value 0. So "tower" takes 6 bytes, and char copy[] = "tower"; makes an array of 6 chars. copy is a new array with its own copy of the letters, and the program may change them. char tag[10] = "tower"; fills the 4 bytes after the '\0' with zeros.

const char *name = "tower"; makes no array. name is a pointer to the bytes of the literal itself. A program must never change a string literal: writing into one is undefined behavior, and on Linux it usually stops the program with a segmentation fault. The const in const char * makes the compiler refuse such a write.

char copy[] = "…" makes an array you may change; const char * points at a literal you must not change.

In almost every expression, the name of an array is converted to a pointer to its first element. This conversion is called decay: the array decays to a pointer. So int *p = visits; makes p point at visits[0].

Two uses of an array do not decay. sizeof visits measures the whole array, in bytes. &visits gives the address of the whole array. (The third is a string literal that fills a char array, as in the section above.)

A function call is an ordinary expression, so an array argument decays too. The function receives a copy of the address of the first element, and nothing about the length. Function calls showed that a parameter written with brackets, such as const int visits[], is a pointer. So inside the function, sizeof visits is the size of a pointer, 8 bytes in the stepper’s build, and sizeof visits / sizeof visits[0] is 8 / 4 = 2, whatever the caller’s array holds.

gcc warns about this line: ‘sizeof’ on array function parameter ‘visits’ will return size of ‘const int *’. The fix is to compute the count where the array is declared, and pass it as a second parameter.

An array passed to a function arrives as a pointer; pass its length beside it.

A string in C is a char array whose text ends with '\0'. No length is stored. strlen, from <string.h>, walks from the first character to the first '\0' and returns the number of characters before it. Text, bytes, and Unicode showed that these are bytes, not letters.

sizeof and strlen answer different questions. In char name[8] = "cuckoo";, sizeof name is 8, the space in the array, and strlen(name) is 6, the length of the text in it.

Writing '\0' into the array ends the string earlier. After name[3] = '\0';, strlen(name) is 3, and printf with %s prints cuc. The other letters are still in the array, but no string function reads past the first '\0'.

A char array with no '\0' in it is not a string. strlen or printf with %s on it reads past the end of the array, which is undefined behavior.

sizeof gives the space in an array; strlen gives the length of the text, up to the first '\0'.

The string functions in <string.h> read each source string up to its '\0', and write wherever the destination pointer points. They receive only pointers, so they cannot know how much space the destination has.

• strcpy(dst, src) copies src and its '\0' into dst. dst needs strlen(src) + 1 bytes.
• strcat(dst, src) adds src after the text already in dst. dst needs strlen(dst) + strlen(src) + 1 bytes.

When dst is too small, both functions write past the end of the array. That is undefined behavior. C prints no error, and the bytes after the array, often another variable, are overwritten.

snprintf(dst, size, format, …), from <stdio.h>, takes the size of the destination. It writes at most size - 1 characters, then '\0', and returns the length that the whole text has. So a result of size or more means the text was cut. Where dst is an array declared in the same function, pass sizeof dst. A function that receives dst as a pointer needs the size as another parameter.

To compare text, use strcmp(a, b), which returns 0 when the characters are equal. == on two strings compares two addresses, as Equality and comparison showed.

strcpy and strcat trust you to give them enough space; snprintf takes the size and tells you when it cut the text.

int visits[2][4] is an array of 2 elements, and each element is an array of 4 ints: 2 floors of the museum, 4 hours each. This is a two-dimensional array. Its 8 ints are stored one row after the other: visits[0][0] to visits[0][3], then visits[1][0] to visits[1][3]. visits[1][2] is floor 1, hour 2.

The outer array decays like any other array. visits becomes a pointer to its first element, and that element is a whole row: an array of 4 ints. The type of that pointer is written int (*)[4].

A parameter for it is written int floors[][4]. The first size may be left empty, because the parameter is a pointer. The row length must be written, because floors[r][h] uses it to find where row r starts. Inside the function, sizeof floors[0] is still 16 bytes, one row. The number of rows is lost, so pass it as another parameter.

A 2-D array decays to a pointer to its first row; write the row length in the parameter and pass the number of rows.

The rules in this lesson explain four bugs that C programmers meet in real programs.

A length computed with sizeof on a parameter. Code that worked in main, such as sizeof title - 1 for the length of a title, is moved into a function and keeps the same line. It still compiles, and it now gives 7, the size of a pointer minus 1, for every title. gcc warns when the parameter is written with brackets, and says nothing when it is written const char *title. Use strlen for a string, and a count parameter for any other array.

strcat into an array without enough space. A program joins parts into a line with strcat in a loop. Every test uses short parts, and the first long part overwrites the variable stored after the line. Give the size to the code that writes, and check it before each write; snprintf does this for you.

== on strings. gcc stores two identical string literals once, so label == wanted can be true in a test where both are literals, and false when the same text comes from input or from a copy. The experiment below shows both. Compare with strcmp.

Writing into a string literal. char *name = "cuckoo"; name[0] = 'C'; compiles without a warning, because in C a literal's type has no const. On Linux it usually stops the program with a segmentation fault. Declare const char * for a literal, and a char array for text you change.

Measure strings with strlen, check the space before you write, compare with strcmp, and never write into a literal.

Work out each number before you read the printf line. Remember where hall is declared, and what measure receives.