Why do books say, “the compiler allocates space for variables in memory”?

Question

Why do books say, "the compiler allocates space for variables in memory". Isn't it the executable which does that? I mean, for example, if I write the following program,

#include <iostream>
using namespace std;

int main()
{
   int foo = 0;
   cout<<foo;
   return 0;
}

and compile it, and get an executable (let it be program.exe), now, if I run program.exe, this executable file will itself command to allocate some space for the variable foo. Won't it ? Please explain why books keep on saying, "the compiler will do this...do that" whereas actually, the compiled executable does that.

Adding another related question to this question, why is sizeof called a compile-time operator ? Isn't it actually a run-time operator ?

Answer 1

It's just a loose use of terminology. Of course the compiler doesn't allocate memory for the program. A more accurate description is that it tells the runtime how much memory to allocate when the program is running.

Until the program is actually run, it isn't in memory (unless it's loaded dynamically, but even that happens during run-time, so out of the scope of the compiler), so there's no memory to speak of.

What those books are talking about is allocating variables whose size is known at compile-time, as opposed to dynamic allocation cin >> x; int * y = new[x];, where the size isn't known.

Answer 2

Of course compiler doesn't "allocate space for variables". Compiler generates a code which allocates space for variables in memory.

I.e. if you have

int foo;
foo = 1;

in source code, compiler may generate a code like

int* fooPtr = allocate sizeof(int)
*fooPtr = 1;

In the x86 architecture, usually that allocate thing will be a single assembly instruction:

sub esp, 4    ; allocate 4 == sizeof(int) bytes on stack
              ; now the value of "esp" is equal to the address of "foo",
              ; i.e. it's "fooPtr"
mov [esp], 1  ; *fooPtr = 1

If you have more than one local variable, compiler will pack them into a structure and allocate them together:

int foo;
int bar;
bar = 1;

will be compiled as

struct Variables { int foo; int bar; };
Variables* v = allocate sizeof(Variables);
v->bar = 1;

or

sub esp, 4+4       ; allocate sizeof(Variables) on stack
mov [esp + 4], 1   ; where 4 is offsetof(Variables, bar)

Answer 3

When we hire an architect to design a house, he or she defines the size of the rooms, etc. and informs the workers (labourers) about it. The labourers do the work accordingly. But still we would say "The architect made the house this way" and not "The labourer made the house this way".

The labourer is just performing the steps defined by the architect. The compiler actually does all the work for checking and defining how much memory is to be allocated, etc. at run time and then those instructions are just followed.