C 底层细节【转】

上次在网上偶遇一题，大致如下：

假设str为在任何函数外申明的变量，分别指出以下str在何时初始化，存于何处，并画出其内存结构图：

1) char str[] = "hello";

2) char str[] = {'h', 'e', 'l', 'l', 'o'};

3) char *str = "hello";  

4) const char str[] = "hello";

明白以下几点即可：

1)编译器把带const的全局变量编译成常量并放在常量区；

2)全局变量和全局常量分别放在内存的不同区域；

3)编译器会在字符串后面添'\0'，而字符数组后面不会；

4)对于已初始化的全局变量，编译器在进入main函数前对其进行初始化；

5)常量字符串的定义方法即在函数外进行类似以下的申明：char *str = "hello";  

另外还有一点，编译器是没法初始化变量的，只能初始化常量。变量从flash到ram的加载要靠内存分配文件来完成。

顺便转载一下这方面的文章：

程序的内存分配（堆和栈区别）

 

 

一、预备知识 程序的内存分配

一个由c/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）     由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap）      一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 
4、文字常量区    ?常量字符串就是放在这里的。 程序结束后由系统释放
5、程序代码区?存放函数体的二进制代码。
二、例子程序 
这是一个前辈写的，非常详细 
//main.cpp 
int a = 0; 全局初始化区 
char *p1; 全局未初始化区 
main() 
{ 
int b; 栈 
char s[] = "abc"; 栈 
char *p2; 栈 
char *p3 = "123456"; 123456\0在常量区，p3在栈上。 
static int c =0； 全局（静态）初始化区 
p1 = (char *)malloc(10); 
p2 = (char *)malloc(20); 
分配得来得10和20字节的区域就在堆区。 
strcpy(p1, "123456"); 123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。 
}

二、堆和栈的理论知识

2.1申请方式 
stack: 
由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间 
heap: 
需要程序员自己申请，并指明大小，在c中malloc函数 
如p1 = (char *)malloc(10); 
在C++中用new运算符 
如p2 = (char *)malloc(10); 
但是注意p1、p2本身是在栈中的。

2.2 
申请后系统的响应 
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。 
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时， 
会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

2.3申请大小的限制 
栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。 
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

2.4申请效率的比较： 
栈由系统自动分配，速度较快。但程序员是无法控制的。 
堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便. 
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

2.5堆和栈中的存储内容 
栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。 
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。 
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

2.6存取效率的比较

char s1[] = "aaaaaaaaaaaaaaa"; 
char *s2 = "bbbbbbbbbbbbbbbbb"; 
aaaaaaaaaaa是在运行时刻赋值的； 
而bbbbbbbbbbb是在编译时就确定的； 
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。 
比如： 
#include 
void main() 
{ 
char a = 1; 
char c[] = "1234567890"; 
char *p ="1234567890"; 
a = c[1]; 
a = p[1]; 
return; 
} 
对应的汇编代码 
10: a = c[1]; 
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh] 
0040106A 88 4D FC mov byte ptr [ebp-4],cl 
11: a = p[1]; 
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h] 
00401070 8A 42 01 mov al,byte ptr [edx+1] 
00401073 88 45 FC mov byte ptr [ebp-4],al 
第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。

2.7小结： 
堆和栈的区别可以用如下的比喻来看出： 
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。 
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大

一般认为在c中分为这几个存储区

1栈 - 有编译器自动分配释放 
2堆 - 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收 
3全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。- 程序结束释放 
4另外还有一个专门放常量的地方。 - 程序结束释放
在函数体中定义的变量通常是在栈上，用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区）,在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static表示只在该函数体内有效。另外，函数中的"adgfdf"这样的字符串存放在常量区。比如：

代码：

int a = 0; //全局初始化区 
char *p1; //全局未初始化区 
main() 
{

int b; //栈
char s[] = "abc"; //栈 
char *p2; //栈 
char *p3 = "123456"; //123456\0在常量区，p3在栈上。 
static int c = 0； //全局（静态）初始化区 
p1 = (char *)malloc(10); 
p2 = (char *)malloc(20); //分配得来得10和20字节的区域就在堆区。 
strcpy(p1, "123456"); //123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一块。 
}

还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。栈的空间大小有限定，vc的缺省是2M。栈不够用的情况一般是程序中分配了大量数组和递归函数层次太深。有一点必须知道，当一个函数调用完返回后它会释放该函数中所有的栈空间。栈是由编译器自动管理的，不用你操心。
堆是动态分配内存的，并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片（有点类似磁盘碎片），因为c分配动态内存时是寻找匹配的内存的。而用栈则不会产生碎片。

在栈上存取数据比通过指针在堆上存取数据快些。一般大家说的堆栈和栈是一样的，就是栈(stack)，而说堆时才是堆heap。栈是先入后出的，一般是由高地址向低地址生长。

有人可能会说，全局内存就是全局变量嘛，有必要专门一章来介绍吗？这么简单的东西，还能玩出花来？我从来没有深究它，不一样写程序吗？关于全局内存这个主题虽然玩不出花来，但确实有些重要，了解这些知识，对于优化程序的时间和空间很有帮助。因为有好几次这样经历，我才决定花一章篇幅来介绍它。

正如大家所知道的，全局变量是放在全局内存中的，但反过来却未必成立。用static修饰的局部变量就是放在放全局内存的，它的作用域是局部的，但生命期是全局的。在有的嵌入式平台中，堆实际上就是一个全局变量，它占用相当大的一块内存，在运行时，把这块内存进行二次分配。

这里我们并不强调全局变量和全局内存的差别。在本文中，全局强调的是它的生命期，而不是它的作用域，所以有时可能把两者的概念互换。

一般来说，在一起定义的两个全局变量，在内存的中位置是相邻的。这是一个简单的常识，但有时挺有用，如果一个全局变量被破坏了，不防先查查其前后相关变量的访问代码，看看是否存在越界访问的可能。

在ELF格式的可执行文件中，全局内存包括三种：bss、data和rodata。其它可执行文件格式与之类似。了解了这三种数据的特点，我们才能充分发挥它们的长处，达到速度与空间的最优化。

1.         bss

已经记不清bss代表Block Storage Start还是Block Started by Symbol。像这我这种没有用过那些史前计算机的人，终究无法明白这样怪异的名字，也就记不住了。不过没有关系，重要的是，我们要清楚bss全局变量有什么样特点，以及如何利用它。

通俗的说，bss是指那些没有初始化的和初始化为0的全局变量。它有什么特点呢，让我们来看看一个小程序的表现。

 

intbss_array[1024 * 1024] = {0};

intmain(intargc, char* argv[])

{

    return 0;

}

 

[root@localhost bss]# gcc -g bss.c -o bss.exe

[root@localhost bss]# ll

total 12

-rw-r--r-- 1 rootroot   84 Jun 22 14:32 bss.c

-rwxr-xr-x 1 rootroot5683Jun 22 14:32 bss.exe

变量bss_array的大小为4M，而可执行文件的大小只有5K。由此可见，bss类型的全局变量只占运行时的内存空间，而不占文件空间。

另外，大多数操作系统，在加载程序时，会把所有的bss全局变量全部清零，无需要你手工去清零。但为保证程序的可移植性，手工把这些变量初始化为0也是一个好习惯。

2.         data

与bss相比，data就容易明白多了，它的名字就暗示着里面存放着数据。当然，如果数据全是零，为了优化考虑，编译器把它当作bss处理。通俗的说，data指那些初始化过（非零）的非const的全局变量。它有什么特点呢，我们还是来看看一个小程序的表现。

 

intdata_array[1024 * 1024] = {1};

intmain(intargc, char* argv[])

{

    return 0;

}

 

[root@localhost data]# gcc -gdata.c -o data.exe

[root@localhost data]# ll

total 4112

-rw-r--r-- 1 rootroot      85 Jun 22 14:35 data.c

-rwxr-xr-x 1 rootroot4200025Jun 22 14:35 data.exe

仅仅是把初始化的值改为非零了，文件就变为4M多。由此可见，data类型的全局变量是即占文件空间，又占用运行时内存空间的。

3.         rodata

rodata的意义同样明显，ro代表read only，即只读数据(const)。关于rodata类型的数据，要注意以下几点：

l         常量不一定就放在rodata里，有的立即数直接编码在指令里，存放在代码段(.text)中。

l         对于字符串常量，编译器会自动去掉重复的字符串，保证一个字符串在一个可执行文件(EXE/SO)中只存在一份拷贝。

l         rodata是在多个进程间是共享的，这可以提高空间利用率。

l         在有的嵌入式系统中，rodata放在ROM(如norflash)里，运行时直接读取ROM内存，无需要加载到RAM内存中。

l         在嵌入式linux系统中，通过一种叫作XIP（就地执行）的技术，也可以直接读取，而无需要加载到RAM内存中。

由此可见，把在运行过程中不会改变的数据设为rodata类型的，是有很多好处的：在多个进程间共享，可以大大提高空间利用率，甚至不占用RAM空间。同时由于rodata在只读的内存页面(page)中，是受保护的，任何试图对它的修改都会被及时发现，这可以帮助提高程序的稳定性。

4.         变量与关键字

static关键字用途太多，以致于让新手模糊。不过，总结起来就有两种作用，改变生命期和限制作用域。如：

l         修饰inline函数：限制作用域

l         修饰普通函数：限制作用域

l         修饰局部变量：改变生命期

l         修饰全局变量：限制作用域

const 关键字倒是比较明了，用const修饰的变量放在rodata里，字符串默认就是常量。对const，注意以下几点就行了。

l         指针常量：指向的数据是常量。如 const char* p = “abc”; p指向的内容是常量 ，但p本身不是常量，你可以让p再指向”123”。

l         常量指针：指针本身是常量。如：char* const p = “abc”; p本身就是常量，你不能让p再指向”123”。

l         指针常量 + 常量指针：指针和指针指向的数据都是常量。const char* const p =”abc”; 两者都是常量，不能再修改。

violatile关键字通常用来修饰多线程共享的全局变量和IO内存。告诉编译器，不要把此类变量优化到寄存器中，每次都要老老实实的从内存中读取，因为它们随时都可能变化。这个关键字可能比较生僻，但千万不要忘了它，否则一个错误让你调试好几天也得不到一点线索。

----------------------------------------------------------------------------------------------------------------------------------------------------

From http://www.cnblogs.com/cassvin/archive/2011/09/16/2178180.html

指针，为何不能在全局作用域内申请内存？？（兼某段C++标准的理解）

好吧。。首先得承认这应该是个较低级的错误，C/C++老手估计不会犯这种错。。但我犯了。。

上个星期帮同学做个简单的控制台C程序，编译器为gcc，我在全局作用域中定义了指针变量并为其申请空间，满心以为这没什么问题，谁知编译的时候弹出了下面的错误：

initializer element is not constant

错误指向我定义全局指针并申请了内存空间的语句。时间较紧，我没有细想，上网搜了一下，结果是c99标准中全局变量和static静态变量的初始化必须使用常量表达式，而且指针不能在全局作用域内申请内存，当时我很疑惑，为何一定要常量表达式，想明白是函数体外不能写执行语句，于是照着改了过来，将申请内存放到函数中执行就O了，后头就没有再思考其背后的缘由了。

今天上午在教室看书（《程序员的自我修养》一书），看到编译二进制文件，程序装载的时候，我突然意识到上个星期这个问题估计同它们有关系，下完课后兴冲冲跑回寝室以求探索真理。

于是我写了个测试程序：

#include <stdio.h>
#include <stdlib.h>

typedef struct _Image
{
        int id;
        struct _Image *next;
} *pImage, Image;

pImage image = (pImage)malloc(sizeof(Image));
int *i = (int *)malloc(sizeof(int));

//Image image;
//int i;

int main(void)
{
        return 0;
}

编译不出意外出现了“intializer element is not constant”的错误，将10，11行注释掉，将13，14行去注释，编译不再有错。

直觉是同编译后生成的二进制文件存储格式有关系。于是翻书，初步验证我的想法：

（我在Linux下编译的，二进制文件格式为ELF，windows虽然是PE也可参考，毕竟都是COFF标准嘛！）

编译器将源码编译为目标文件or二进制文件时，会将数据存放于存放于各个段中。按照ELF/COFF的标准，初始化了的全局变量和局部static变量存放于.data段，.bss段记录未初始化的全局变量和局部static变量。（注意，.bss不会存放数据，只用于为变量预留空间）。将10，11注释，13，14行去注释后编译所得的image和i变量存放与.bss段中，程序装载的时候会将.bss段映射到内存中并为该两变量开辟空间，整个过程是没有错的。反观，之前的代码（上面贴出的代码）编译后为何报错？？因为image和i并没有使用常量表达式为其初始化。用常量表达式初始化，程序在编译的时候才能够顺利获得定义式右值（即我们给出的常量表达式）并将其值写入.data段中。举个例子，假如我这么为全局变量赋值：

int a = 1;
int b = a;
//(注意：在全局作用域中)

此时编译肯定还是会报出之前同样的错误。全局变量a的赋值是没有错的，此时数据1顺利写入.data段中同a“绑定”，但是全局变量b的赋值却不尽人意了。为何？首先，b使用a变量进行初始化，但是b真能取到a的值吗？？你也许会问，a不是已经赋值为1了吗？？为神马不可以这么做？？

有些人可能以一句话解释其中缘由：执行语句不可以置于函数体外。是的这没错，但是你想到没有为什么会是这样子？？难道只是一个恶心的规定。哦不是的，任何事情总是有规律的我相信，规则的背后总还是有规则的存在。

对于这个问题，首先我们得明确编译的概念。编译是将程序代码转换为目标代码的过程。它是一个翻译的过程，不能执行程序。int b = a，这一句需要我们到内存中执行程序才能够实现，程序需要先取到a的值，再把该值复制到b对应的内存空间。但是现在我们是在编译耶！编译程序只将a的值写入.data并记录a符号之后就没有变量a什么事情了，b肯定是取不到a的值的！

好了，我们理解了那条标准制定的背后的原因，现在有关指针在全局作用域中申请内存空间错误的理解也就水到渠成了。

由“初始化了的全局变量和局部static变量存放于.data段，.bss段记录未初始化的全局变量和局部static变量”这句话可知，在我之前的程序中，我申请内存来初始化我的两个指针变量image和i，毫无疑问image和i应位于.data段上。定义指针没错，问题是，我现在能够申请到内存吗？？不要以为这段代码是在程序装入到内存后执行的。实际上，因为编译器判定你是全局变量，此时它就是要你拿出常量来初始化它的变量好让它能往.data段中写数据，所以以编译器的逻辑你需要实实在在的从内存中申请到内存并把他们的值写入到.data段中。但实际可行吗？？不可行。。且不说编译器不会帮你申请，程序需要在链接装载到内存后才会在虚拟内存中映射自己的堆栈段。。于是，这段代码夭折了，它理所当然的报错了。。

over，写blog总是不易的，何况我不能保证我的想法是不是完全正确的，这只是我的个人想法，不过起码它自园其说了哈哈，有些地方表达的估计不了解这块的人不清楚，原谅我吧，小弟文笔实在......

如果上面有什么错误请各位大佬严厉指出哈哈！！

标签: C/C++