What happens behind the scenes when you declare a variable in C (and other languages)?

Question

I am a fairly beginner programmer in C, and I had always assumed that the way variable declaration worked was that when you declare a variable like int x;, you were telling the compiler to set aside memory for that variable, which would then be initialised if you then wrote something like x = 3;, and that perhaps the compiler might shuffle that declaration to somewhere more efficient if it can when compiling.

However I recently read that this is not what happens. So what happens, and why? Does something concrete happen behind the scenes, or are declarations effectively just messages to the compiler with no analogue in the eventual binary that it spits out? And how does all this apply to function declarations?

Answer 1

Both statements are true, at different “levels” in the C standard.

The C standard is written largely describing how a C implementation acts inside an imaginary abstract computer. In this model, when a variable is defined (not just declared), memory is reserved for it.

However, the C standard says that an actual implementation only needs to produce results as if it followed the abstract model. The standard says that only certain parts of the abstract model must be obervable. Most notably, the output of the program is observable.

Because of this rule, a compiler may change the internal parts of a program in any way it wants, as long as the output and other observable behavior remains the same. So, when the compiler sees that you use some variable x in a particular way and that it can get the same result another way without using memory for x, the compiler is allowed to change the program so that there is no actual memory used for x.

Answer 2

I think your first paragraph is fine, and as true as it ever was.

I like to draw pictures like this, with little labeled boxes showing the memory that has been set aside for various variables:

char c = 'A';
int i = 123;
int *ip = &i;

    +---+
 c: | A |
    +---+

    +---------+
 i: |   123   |
    +---------+
         ^
         |
    +----|----+
ip: |    *    |
    +---------+

And then what I think about is making sure the contents of each box is appropriate: right type, doesn't overflow. For each pointer, I think about whether that little arrow points somewhere valid.

If variables are local, they're typically stored in a stack frame. If variables are global, they're typically stored in the data segment. But, you're right, they might get rearranged, so you can't count on one coming just before, or just after, another. (Nor, in a sane or portable program, would you want to, of course.)