blocks|key|163980|text|可执行文件描述为静态变量分配的空间。当您运行可执行文件时，此分配由系统完成。因此，1kB的静态变量不会增加1kb的可执行文件的大小：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|163981|static+char[1024];|code-block|syntax|javascript|163982|当然，除非您指定了初始化器：|163983|static+char[1024]+=+{+1,+2,+3,+4,+...+};|163984|因此，除了“机器语言”(即CPU指令)之外，可执行文件还包含对所需内存布局的描述。|163985|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

An executable describes what space to allocate for static variables. This allocation is done by the system, when you run the executable. So your 1kB static variable won't increase the size of the executable with 1kB:

<pre><code>static char[1024];
</code></pre>

Unless of course you specify an initializer:

<pre><code>static char[1024] = { 1, 2, 3, 4, ... };
</code></pre>

So, in addition to 'machine language' (i.e. CPU instructions), an executable contains a description of the required memory layout.

blocks|key|163995|text|你是正确的。内存实际上是在加载时分配(分页)的，即当可执行文件被放入(虚拟)内存时。内存也可以在那个时刻初始化。编译器只是创建了一个内存映射。顺便说一下，堆栈和堆空间也是在加载时分配的！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|163996|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You are right. Memory is actually allocated (paged) at load time, i.e. when the executable file is brought into (virtual) memory. Memory can also be initialized on that moment. The compiler just creates a memory map. [By the way, stack and heap spaces are also allocated at load time !]

blocks|key|164034|text|我觉得你应该退后一步。编译时分配的内存...这意味着什么呢？这是否意味着尚未制造的芯片上的内存正在以某种方式保留给尚未设计的计算机？不是的。不，时间旅行，没有可以操纵宇宙的编译器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|164035|因此，这一定意味着编译器在运行时以某种方式生成指令来分配内存。但是如果你从正确的角度来看，编译器会生成所有的指令，所以有什么不同呢？不同之处在于编译器决定，并且在运行时，您的代码不能改变或修改其决定。如果它在编译时决定需要50个字节，那么在运行时，您不能让它决定分配60个字节--这个决定已经做出。|164036|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I think you need to step back a bit. Memory allocated at compile time.... What can that mean? Can it mean that memory on chips that have not yet been manufactured, for computers that have not yet been designed, is somehow being reserved? No. No, time travel, no compilers that can manipulate the universe.

So, it must mean that the compiler generates instructions to allocate that memory somehow at runtime. But if you look at it in from the right angle, the compiler generates all instructions, so what can be the difference. The difference is that the compiler decides, and at runtime, your code can not change or modify its decisions. If it decided it needed 50 bytes at compile time, at runtime, you can't make it decide to allocate 60 -- that decision has already been made.

blocks|key|164203|text|我想通过一些图表来解释这些概念。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|164204|这是真的，内存不能在编译时分配。但是，那么实际上在编译时会发生什么呢？|164205|这就是解释。例如，一个程序有四个变量x，y，z和k。现在，在编译时，它只是制作一个内存映射，其中这些变量相互之间的位置是确定的。此图将更好地说明这一点。|164206|现在想象一下，没有程序在内存中运行。我用一个大的空矩形来表示。|164207|​|164208|📷|atomic|offset|length|164209|164210|接下来，执行该程序的第一个实例。您可以将其可视化，如下所示。这是实际分配内存的时间。|164211|164212|164213|164214|当这个程序的第二个实例运行时，内存将如下所示。|164215|164216|164217|164218|第三个..。|164219|164220|164221|164222|以此类推。|164223|我希望这个可视化很好地解释了这个概念。|164224|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/c4b0b0aa12004a5ab7c9b670d7ebb590.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/c1d5d12f809bf5c904dfde4fe8e04c84.png|2|https://ask.qcloudimg.com/http-save/yehe-900000/5b75791de041318c8ed3197e7c6b5648.png|3|https://ask.qcloudimg.com/http-save/yehe-900000/8ea6a7714988cac5de338b93943c7e1a.png^0|0|0|0|0|0|0|1|0|0|0|0|0|0|1|1|0|0|0|0|0|1|2|0|0|0|0|0|1|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1R|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1S|8|@]|9|@$M|1T|N|1U|1|1V]]|A|$]]|$1|O|3|I|5|6|7|1W|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1X|8|@]|9|@]|A|$]]|$1|R|3|I|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|S|3|K|5|L|7|1Z|8|@]|9|@$M|20|N|21|1|22]]|A|$]]|$1|T|3|I|5|6|7|23|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|24|8|@]|9|@]|A|$]]|$1|W|3|I|5|6|7|25|8|@]|9|@]|A|$]]|$1|X|3|K|5|L|7|26|8|@]|9|@$M|27|N|28|1|29]]|A|$]]|$1|Y|3|I|5|6|7|2A|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2B|8|@]|9|@]|A|$]]|$1|11|3|I|5|6|7|2C|8|@]|9|@]|A|$]]|$1|12|3|K|5|L|7|2D|8|@]|9|@$M|2E|N|2F|1|2G]]|A|$]]|$1|13|3|I|5|6|7|2H|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|2I|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2J|8|@]|9|@]|A|$]]|$1|18|3|-4|5|6|7|2K|8|@]|9|@]|A|$]]]|19|$1A|$5|1B|1C|1D|A|$1E|1F|1G|-4]]|1H|$5|1B|1C|1D|A|$1E|1I|1G|-4]]|1J|$5|1B|1C|1D|A|$1E|1K|1G|-4]]|1L|$5|1B|1C|1D|A|$1E|1M|1G|-4]]]]

I would like to explain these concepts with the help of few diagrams.

This is true that memory cannot be allocated at compile time, for sure.
But, then what happens in fact at compile time.

Here comes the explanation.
Say, for example a program has four variables x,y,z and k.
Now, at compile time it simply makes a memory map, where the location of these variables with respect to each other is ascertained.
This diagram will illustrate it better.

Now imagine, no program is running in memory.
This I show by a big empty rectangle.

<img src="https://i.stack.imgur.com/6OTAC.png" alt="empty field">

Next, the first instance of this program is executed.
You can visualize it as follows.
This is the time when actually memory is allocated.

<img src="https://i.stack.imgur.com/pw2Aa.png" alt="first instance">

When second instance of this program is running, the memory would look like as follows.

<img src="https://i.stack.imgur.com/EwkFI.png" alt="second instance">

And the third ..

<img src="https://i.stack.imgur.com/vXb2f.png" alt="third instance">

So on and so forth.

I hope this visualization explains this concept well.

blocks|key|4670327|text|在公认的答案中给出了非常好的解释。以防万一我会把我发现有用的链接贴出来。https://www.tenouk.com/ModuleW.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4670328|entityMap|0|LINK|mutability|MUTABLE|url|https://www.tenouk.com/ModuleW.html^0|10|Z|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

There is very nice explanation given in the accepted answer. Just in case i will post the link which i have found useful.
<a href="https://www.tenouk.com/ModuleW.html" rel="nofollow noreferrer">https://www.tenouk.com/ModuleW.html</a>

blocks|key|4670419|text|编译器所做的众多事情之一就是创建和维护SYMTAB(section.symtab下的符号表)。这将纯粹由编译器使用任何数据结构(List，Trees...etc)创建和维护，而不是供开发人员使用。开发人员发出的任何访问请求都将首先命中此处。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4670420|现在关于符号表，我们只需要知道两列符号名称和偏移量。|4670421|Symbol+Name列将具有变量名称，而offset列将具有偏移值。|4670422|让我们用一个例子来看看这个：|4670423|int++a++,++b++,++c++;|code-block|syntax|javascript|4670424|现在我们都知道寄存器Stack_Pointer(sp)指向堆栈内存的顶部。假设它是sp+=+1000。|4670425|现在，Symbol+Name列中将有三个值，a、b和c。提醒您所有变量a将位于堆栈内存的顶部。|4670426|因此，a的等效偏移值将为0。(编译时Offset_Value)|4670427|那么b和它的等效偏移值将是1。(编译时Offset_Value)|4670428|那么c和它的等效偏移值将是2。(编译时Offset_Value)|4670429|现在计算a的物理地址(或)运行时内存地址=+(sp+%2B+offset_value+of+a)+=+(1000+%2B+0)+=+1000|4670430|现在计算b的物理地址(或)运行时内存地址=(b的sp-+offset_value+)=(1,000-+1)+=+996|4670431|现在计算c的物理地址(或)运行时内存地址=(c的sp-+offset_value+)=(1,000-+2)+=+992|4670432|因此，在编译时，我们将只有偏移量，并且只有在运行时才会计算实际的物理地址。|4670433|注意:只有在程序加载后，才会分配Stack_Pointer值。指针运算在Stack_Pointer寄存器和变量偏移量之间进行，以计算变量的物理地址。|4670434|++++++++"POINTERS+AND+POINTER+ARITHMETIC,+WAY+OF+THE+PROGRAMMING+WORLD"|4670435|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1C|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1D|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1E|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1F|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1H|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1I|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1J|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1K|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1L|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1M|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1N|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1O|8|@]|9|@]|A|$]]|$1|16|3|17|5|J|7|1P|8|@]|9|@]|A|$K|L]]|$1|18|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|19|$]]

One among the many thing what a compiler does is that create and maintain a SYMTAB(Symbol Table under the section.symtab). This will be purely created and maintained by compilers using any Data Structure(List, Trees...etc) and not for the developers eyes. Any access request made by the developers this is where it will hit first.
Now about the Symbol Table,
We only need to know about the two columns Symbol Name and the Offset.
Symbol Name column will have the variable names and the offset column will have the offset value.
Lets see this with an example:
<pre><code>int a , b , c ;
</code></pre>
Now we all know that the register Stack_Pointer(sp) points to the Top of the Stack Memory. Let that be sp = 1000.
Now the Symbol Name column will have three values in it a then b and then c. Reminding you all that variable a will be at the top of the stack memory.
So a's equivalent offset value will be 0.
(Compile Time Offset_Value)
Then b and its equivalent offset value will be 1. (Compile Time Offset_Value)
Then c and its equivalent offset value will be 2. (Compile Time Offset_Value)
Now calculating a's Physical address (or) Runtime Memory Address = (sp + offset_value of a)
= (1000 + 0) = 1000
Now calculating b's Physical address (or) Runtime Memory Address = (sp - offset_value of b)
= (1000 - 1) = 996
Now calculating c's Physical address (or) Runtime Memory Address = (sp - offset_value of c)
= (1000 - 2) = 992
Therefore at the time of the compilation we will only be having the offset values and only during the runtime the actual physical addresses are calculated.
Note:
Stack_Pointer value will be assigned only after the program is loaded. Pointer Arithmetic happens between the Stack_Pointer register and the variables offset to calculate the variables Physical Address.
<pre><code> &quot;POINTERS AND POINTER ARITHMETIC, WAY OF THE PROGRAMMING WORLD&quot;
</code></pre>

In programming languages like C and C++, people often refer to static and dynamic memory allocation. I understand the concept but the phrase "All memory was allocated (reserved) during compile time" always confuses me.

Compilation, as I understand it, converts high level C/C++ code to machine language and outputs an executable file. How is memory "allocated" in a compiled file ? Isn't memory always allocated in the RAM with all the virtual memory management stuff ? 

Isn't memory allocation by definition a runtime concept ?

If I make a 1KB statically allocated variable in my C/C++ code, will that increase the size of the executable by the same amount ?

This is one of the pages where the phrase is used under the heading "Static allocation". 

<a href="http://blogs.msdn.com/b/abhinaba/archive/2009/01/16/back-to-basics-memory-allocation-a-walk-down-the-history.aspx">Back To Basics: Memory allocation, a walk down the history</a>

What does "Memory allocated at compile time" really mean?

数据结构

内存管理

内存映射

编译器

在C和C++等编程语言中，人们经常提到静态和动态内存分配。我理解这个概念，但“编译时分配(保留)所有内存”这句话总是让我感到困惑。据我所知，编译将高级C/C++代码转换为机器语言，并输出一个可执行文件。在编译后的文件中内存是如何“分配”的？内存不是总是与所有虚拟内存管理内容一起分配在RAM中吗？按定义分配内存不是一个运...

问“编译时分配的内存”到底是什么意思？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“编译时分配的内存”到底是什么意思？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“编译时分配的内存”到底是什么意思？
EN