C initialization and storage duration.

Variables showed that a C variable names an object: a region of memory that holds a value of one type. The part of a run during which an object exists, and keeps the last value stored in it, is its lifetime. Its storage duration decides how long that lifetime is. Three storage durations matter in ordinary programs.

A variable declared inside a block without the keyword static has automatic storage duration. Each time the block runs, a new object is created, and it stops existing when the block ends. A function body is a block, so each call gets its own local variables.

A variable declared outside every function, or inside a block with static, has static storage duration. There is one object for the whole run. Its initializer runs once, before main starts, not each time the program reaches the declaration. So a static local keeps its value from one call to the next. Because the value is set before main, the initializer must be a constant expression, one the compiler can compute: static int desk = first_desk(); is refused with error: initializer element is not constant.

The third kind is allocated storage duration. malloc(n), declared in <stdlib.h>, returns a pointer to a new block of n bytes, and the block exists until the program passes that pointer to free. The end of a block or a call does not end it. Stack and heap, a later lesson, shows malloc and free at work.

An automatic local is a new object at every call; a static object is one object for the whole run, initialized once.

A static object without an initializer starts at zero: 0 for numbers, and a null pointer for pointers. An automatic object without an initializer holds an indeterminate value: whatever was left in its memory. Each call makes a new object, but the memory under it is used again, so the leftover can come from an earlier call.

Do not read an automatic variable before your code gives it a value. If the program never takes its address with &, the read is undefined behavior: the C standard sets no requirements for the whole program. If the address is taken, the value is still not one you can count on.

gcc helps, but it does not catch every case. With -Wall, which the stepper uses, gcc reports a read that comes before any line could have stored a value. The stepper shows it under Compiler warnings, for example:

warning: ‘extra’ may be used uninitialized [-Wmaybe-uninitialized]

A warning does not stop the build. In the experiment below, extra is read only inside an if that this run never enters, so the run is defined and still gets the warning.

A static object without an initializer starts at zero; an automatic one holds an indeterminate value, which the program must not read.

An initializer is the = … part of a declaration. int open[5]; declares an array: 5 ints stored side by side, open[0] to open[4]. An array initializer lists values in braces, in order. When the list is shorter than the array, C sets every element it does not mention to 0. So {1} sets open[0] to 1 and the other four elements to 0. {0} is the usual way to write an array of zeros.

A designated initializer names the element: {[2] = 4, [5] = 1} sets those two elements and sets the rest to 0. A value after a designated one goes to the next element: {[2] = 4, 7} sets team[3] to 7.

A string literal can fill a char array. char sign[8] = "Quiet"; stores the five letters, then the null character '\0' that ends a string, then zeros in the last two bytes. Leave room for the '\0': char sign[5] = "Quiet"; still compiles, but stores no '\0', so sign is not a string.

These rules hold for automatic arrays too: an initializer, even {0}, sets every element. An automatic array with no initializer is indeterminate in every element.

An initializer shorter than its array sets the rest of the array to zero, for an automatic array too.

Scope and lifetime answer different questions. Scope, from Scope and shadowing, is where in the source code a name can be used. Lifetime is when, during the run, the object exists.

For an automatic local the two almost match: the name can be used to the end of its block, and the object ends with that block. A static local separates them. Its name has block scope: no code outside its block can use that name. Its object has static storage duration: it exists for the whole run. So a function can return the address of a static local, and the code that called it can use that pointer after the call has returned.

At file scope, outside every function, static means something else. Every variable there already has static storage duration, and static gives its name internal linkage: other source files of the same program cannot refer to it.

Scope is where a name can be used; lifetime is when its object exists. A static local has block scope and lasts for the whole run.

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

A loop total with no starting value. int total; followed by a loop that adds to total reads an indeterminate value on the first pass. In the stepper’s build this loop gave no warning, although the same read outside a loop does warn. Give the total its starting value in the declaration, as below.

A static local in a function that must start fresh. static int count = 0; sets count once, before main, not at each call. A function that counts with it is right on its first call and wrong on the next, so a test that calls it once passes. Every caller shares the one object, nothing outside the function can reset it, and two threads (parts of one program that run at the same time) that call it at once can damage the count. Keep the count in an automatic variable, or let the caller keep it and pass its address.

A returned pointer to an automatic array. gcc warns:

warning: function returns address of local variable [-Wreturn-local-addr]

The array’s lifetime ends with the call, so the pointer is dangling: it points to memory that no longer exists. Let the caller pass in an array to fill. Making the array static removes the warning, but then every call returns the same array and overwrites the last result.

Zeros that disappear when a table moves to malloc. A global or static array starts at zero. Memory from malloc is indeterminate, like an automatic variable. calloc(count, size), also from <stdlib.h>, returns memory with every byte set to 0.

Give every automatic variable its first value, keep state that must start fresh out of static locals, and never return the address of an automatic object.

Sort the three variables that book uses by storage duration before you read main.