Which are the executable statements?

Question

Many times, reading around, I found definitions like this one:

Definitions are not executable statements. They’re messages to the compiler. For example, the definition int i; simply tells the compiler the type of variable i and instructs the compiler to reserve space in memory for the variable.

Statements like this one leave me always confused, because, IMHO, everything can be seem as "requiring an action". For example, in this case, the computer has to perform some actions to allocate some memory.

So what are those statements really referring to?

Answer 1

C language recognizes the similarity between local declarations and statements. This is reflected in

6.8 Statements and blocks

3 A block allows a set of declarations and statements to be grouped into one syntactic unit. The initializers of objects that have automatic storage duration, and the variable length array declarators of ordinary identifiers with block scope, are evaluated and the values are stored in the objects (including storing an indeterminate value in objects without an initializer) each time the declaration is reached in the order of execution, as if it were a statement, and within each declaration in the order that declarators appear.

However, formally, declarations are not classified as statements in C.

Note that "statement-ish" properties of a local declarations are actually tied to initialization. As for memory allocation... the language does not actually specify when exactly that memory allocation occurs. It does not necessarily occur when control passes over the definition.

External definitions are definitely not statements since they are not involved in the control flow.

Answer 2

Imagine getting a new car from a car dealer. They will show you where the switches for the headlights are, how the gears are arranged and how to open the trunk. This is all declarative. Nothing is actually happening. In terms of a compiler: no output will be created.

Once you start using the car, you will perform different actions according to the knowledge you've been given. You will shift gears accordingly and use the proper switch to turn on the headlights. In terms fo a compiler: the compiled output will vary depending on the declarations given beforehand.

Answer 3

Compilers translate the C language into machine code, which can be executed by the CPU. It's often easy to see which bytes of machine code correspond to which statements in your C code. Debuggers use this correspondence when showing how your C code runs.

So the meaning of "a declaration is not an executable statement" is that no machine code corresponds to a declaration. This also means that:

• CPU doesn't spend any time to "run" the declaration (but the compiler does spend time to examine it)
• A visual debugger will "skip" the declaration when running your program step by step

---

You can see this in the online compiler explorer, which does this for C++, but it's close enough to C. It paints each line of code in a different colour to visualize which lines generate which machine code. An example from there:

Input C/C++ code

int square(int num)             // painted in white
{                               // painted in teal
    int result;                 // painted in white
    result = num * num;         // painted in yellow
    return result;              // painted in gray
}                               // painted in red

Output assembly code (represents machine code)

square(int):
        push    rbp                          // painted in green
        mov     rbp, rsp                     // painted in green
        mov     DWORD PTR [rbp-20], edi      // painted in green
        mov     eax, DWORD PTR [rbp-20]      // painted in yellow
        imul    eax, DWORD PTR [rbp-20]      // painted in yellow
        mov     DWORD PTR [rbp-4], eax       // painted in yellow
        mov     eax, DWORD PTR [rbp-4]       // painted in gray
        pop     rbp                          // painted in red
        ret                                  // painted in red

You can see that lines painted in white (declarations) "don't generate code", and "are not executable statements".

---

The "not executable" idea is not a hard rule; just a guideline. Some situations where a declaration is "executable":

int x = 0; // a trivial calculation, but it will appear in machine code
int y = x * (x + 1); // a non-trivial calculation
int a[rand() % 10 + 1]; // possible without initialization too (suggested by by user AnT)

Answer 4

In the impreative programming paradigm, a statement is a description of what and how the program should take an action, while a declaration is a description of what the tools the program should use. The line int i only declares that the program requires an object of type (int), and the line int i = 0 declares that the program requires an object of type (int) with an initial value of zero. None of those are statements, even both could require action from the program.

You are right that every line of code could potentially⁽¹⁾ involve some "execution" from the program. But the distinction is about what the language is, as a description of algorithms, not how it is implemented in real-world machines.

^{(1): any declaration or statement can be optimized-out, for instance}

Answer 5

int i; in the global context or static int i; anywhere reserve space for i and zero-initialize it. These allocations are typically glued with other allocations and done in one fell swoop when the program is loaded.

int i inside a function does potentially nothing if you don't use the variable. If you do use it, the compiler will try to use it as an alias for a CPU register. If all registers are taken and an old register variable cannot be reused or if you take the address of the variable, the compiler will need to spill the variable into the stack. All the stack variables of a function will typically be allocated upon entering the function, all at once, and the allocation will be done by incrementing (/decrementing) the stack pointer (in a register, hidden from you when you're in C). In essence, the CPU-time cost of allocating an automatic variable will be at most a fraction of the time it takes to subtract an integer.