堆与栈,静态变量和全局变量的区别
c语言的变量范围
c语言的变量范围C语言是一种强大而灵活的编程语言，它具有丰富的变量范围规则，这些规则决定了变量的可见性和生命周期。
在本文中，我将详细介绍C语言的变量范围，包括全局变量、局部变量和静态变量。
一、全局变量全局变量是在函数外部定义的变量，它可以在程序的任何地方使用。
全局变量的作用域从定义处开始，一直延伸到文件的末尾。
这意味着全局变量在整个程序中都是可见的，并且可以被多个函数共享和修改。
全局变量的好处是可以在不同的函数中共享数据，但同时也存在一些潜在的问题。
由于全局变量的可见性很高，所以可能会被意外地修改，导致程序出现错误。
另外，全局变量的使用也会增加程序的复杂性，不利于维护和调试。
因此，在使用全局变量时需要谨慎考虑。
二、局部变量局部变量是在函数内部定义的变量，它只能在定义它的函数内部使用。
局部变量的作用域仅限于所在的函数，一旦函数执行完毕，局部变量就会被销毁。
局部变量的生命周期取决于函数的调用和返回。
局部变量的作用是在函数内部临时存储数据，仅供该函数使用。
由于局部变量的作用域较小，所以不会被其他函数意外地修改，从而增加了程序的安全性。
此外，局部变量的使用也有助于提高代码的可读性和可维护性。
三、静态变量静态变量是在函数内部或者全局变量外部定义的变量，它与局部变量和全局变量有一些不同之处。
静态变量的作用域仍然是局部的，只能在定义它的函数内部或者全局范围内使用。
但静态变量的生命周期更长，它会在程序的整个运行过程中一直存在。
静态变量的特点是只能被初始化一次，即使函数退出，静态变量的值也会被保留。
这样可以实现在多次调用同一个函数时，静态变量的值可以被保持。
静态变量对于需要记录某些状态或计数的情况非常有用。
四、变量范围的注意事项在使用C语言的变量范围时，需要注意以下几点：1. 变量的命名要具有可读性和表达性，以便于理解和维护代码；2. 避免过多使用全局变量，尽量使用局部变量来实现数据的封装和保护；3. 在使用全局变量时，需要注意对其进行适当的封装和限制访问权限，以避免意外修改；4. 在使用静态变量时，需要注意初始化的时机和值的保持；5. 注意变量的生命周期，合理分配内存资源，避免内存泄漏和访问非法内存的情况。
单片机C语言 必知的数据存储与程序编写知识 附单片机应用编程知识介绍
一、五大内存分区内存分成5个区，它们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
1、栈区（StaCk）：FIFo就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。
里面的变量通常是局部变量、函数参数等。
2、堆区（heap）：就是那些由new分配的内存块，它们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
3、自由存储区：就是那些由malloc等分配的内存块，它和堆是十分相似的，不过它是用free 来结束自己的生命。
4、全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
5、常量存储区：这是一块比较特殊的存储区，它们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）code/data/stack内存主要分为代码段，数据段和堆栈。
代码段放程序代码，属于只读内存。
数据段存放全局变量，静态变量，常量等，堆里存放自己malloc或new出来的变量，其他变量就存放在栈里，堆栈之间空间是有浮动的。
数据段的内存会到程序执行完才释放。
调用函数先找到函数的入口地址，然后计算给函数的形参和临时变量在栈里分配空间，拷贝实参的副本传给形参，然后进行压栈操作，函数执行完再进行弹栈操作。
字符常量一般放在数据段，而且相同的字符常量只会存一份。
二、C语言程序的存储区域1、由C语言代码（文本文件）形成可执行程序（二进制文件），需要经过编译-汇编-连接三个阶段。
编译过程把C语言文本文件生成汇编程序，汇编过程把汇编程序形成二进制机器代码，连接过程则将各个源文件生成的二进制机器代码文件组合成一个文件。
2、C语言编写的程序经过编译-连接后，将形成一个统一文件，它由几个部分组成。
堆栈及静态数据区详解
堆、栈及静态数据区详解五大内存分区在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。
里面的变量通常是局部变量、函数参数等。
堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free 来结束自己的生命的。
全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）明确区分堆与栈在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。
首先，我们举一个例子：void f() { int* p=new int[5]; }这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。
在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：00401028 push 14h0040102A call operator new (00401060)0040102F add esp,400401032 mov dword ptr [ebp-8],eax00401035 mov eax,dword ptr [ebp-8]00401038 mov dword ptr [ebp-4],eax这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie 信息去进行释放内存的工作。
c语言的内存结构
c语言的内存结构C语言是一种高级编程语言，但实际上在计算机中运行时，C语言程序会被编译成可执行文件，然后在计算机内存中运行。
因此，了解C 语言的内存结构对于理解C程序的运行及性能优化至关重要。
C语言的内存结构主要可以分为以下几个部分：栈（Stack）、堆（Heap）、全局内存（Global Memory）和代码区（Code Segment）。
首先是栈（Stack），栈是一种自动分配和释放内存的数据结构。
它用于存储局部变量、函数参数和函数调用信息等。
栈的特点是后进先出（LIFO），也就是最后进入的数据最先被释放。
栈的大小在程序运行时是固定的，一般由编译器设置。
栈的操作速度较快，但内存空间有限。
其次是堆（Heap），堆是一种动态分配和释放内存的数据结构。
它用于存储动态分配的变量、数据结构和对象等。
堆的大小一般由操作系统管理，并且可以在运行时进行动态扩展。
堆的操作相对较慢，因为需要手动分配和释放内存，并且容易产生内存碎片。
全局内存（Global Memory）是用于存储全局变量和静态变量的区域。
全局变量在程序的生命周期内都存在，并且可以在多个函数之间共享。
静态变量作用于其所在的函数内，但是生命周期与全局变量相同。
全局内存由编译器进行分配和管理。
代码区（Code Segment）存储了程序的指令集合，它是只读的。
在程序运行时，代码区的指令会被一条一条地执行。
代码区的大小由编译器决定，并且在程序执行过程中不能修改。
此外，C语言还具有特殊的内存区域，如常量区和字符串常量区。
常量区用于存储常量数据，如字符串常量和全局常量等。
常量区的数据是只读的，且在程序的整个生命周期内存在。
字符串常量区是常量区的一个子区域，用于存储字符串常量。
在C语言中，内存分配和释放是程序员的责任。
通过使用malloc和free等函数，程序员可以在堆中动态地分配和释放内存，从而灵活地管理程序的内存使用。
不过，应当注意避免内存泄漏和野指针等问题，以免出现内存错误和性能问题。
内存中堆栈的划分
栈和堆的区别 (转) 终于知道区别了(2007-09-12 08:50:49)转载标签：IT/科技一个由 c/C++ 编译的程序占用的内存分为以下几个部分：1 、栈区（ stack ）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。
其操作方式类似于数据结构中的栈。
2 、堆区（ heap ）—一般由程序员分配释放，若程序员不释放，程序结束时可能由 OS 回收。
注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3 、全局区（静态区）（ static ）—全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
程序结束后由有系统释放。
4 、文字常量区—常量字符串就是放在这里的。
程序结束后由系统释放。
5 、程序代码区—存放函数体的二进制代码。
例子程序：这是一个前辈写的，非常详细//main.cppint a = 0; //全局初始化区char *p1; //全局未初始化区main（）{int b; 栈char s[] = "abc"; //栈char *p2; //栈char *p3 = "123456"; //123456在常量区，p3在栈上。
static int c =0; //全局（静态）初始化区p1 = （char *）malloc（10）;p2 = （char *）malloc（20）; //分配得来得10和20字节的区域就在堆区。
strcpy（p1, "123456"）; //123456放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}栈：在 Windows 下，栈是向低地址扩展的数据结构，是一块连续的内存的区域。
这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS 下，栈的大小是 2M （也有的说是 1M ，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示 overflow 。
局部变量、全局变量、静态变量的含义及存储位置
局部变量、全局变量、静态变量的含义及存储位置1.局部变量在⼀个函数内部定义的变量是内部变量，它只在本函数范围内有效，也就是说只有在本函数内才能使⽤它们，在此函数以外时不能使⽤这些变量的，它们称为局部变量。
局部变量保存在动态数据区的栈中，只有在所在函数被调⽤时才动态地为变量分配存储单元。
1).主函数main中定义的变量也只在主函数中有效.2).不同函数中可以使⽤名字相同的变量，它们代表不同的对象，互不⼲扰.3).形参也是局部变量.4).在复合语句中定义的局部变量，这些变量只在本复合语句中有效.2.全局变量在函数外定义的变量是外部变量，外部变量是全局变量，全局变量可以为本⽂件中其它函数所共⽤，它的有效范围从定义变量的位置开始到本源⽂件结束。
全局变量位于静态数据区中。
1).设全局变量的作⽤：增加了函数间数据联系的渠道.2).建议不再必要的时候不要使⽤全局变量，因为a.全局变量在程序的全部执⾏过程中都占⽤存储单元.b.它使函数的通⽤性降低了3).如果外部变量在⽂件开头定义，则在整个⽂件范围内都可以使⽤该外部变量，如果不再⽂件开头定义，按上⾯规定作⽤范围只限于定义点到⽂件终了.如果在定义点之前的函数想引⽤该外部变量，则应该在该函数中⽤关键字extern作外部变量说明.4).如果在同⼀个源⽂件中，外部变量与局部变量同名，则在局部变量的作⽤范围内，外部变量不起作⽤.3.静态变量静态变量并不是说其就不能改变值，不能改变值的量叫常量。
其拥有的值是可变的，⽽且它会保持最新的值。
说其静态，是因为它不会随着函数的调⽤和退出⽽发⽣变化。
即static局部变量只被初始化⼀次，下⼀次依据上⼀次结果值;静态变量的作⽤范围要看静态变量的位置，如果在函数⾥，则作⽤范围就是这个函数。
静态变量属于静态存储⽅式，其存储空间为内存中的静态数据区（在静态存储区内分配存储单元），该区域中的数据在整个程序的运⾏期间⼀直占⽤这些存储空间（在程序整个运⾏期间都不释放），也可以认为是其内存地址不变，直到整个程序运⾏结束（相反，⽽auto⾃动变量，即动态局部变量，属于动态存储类别，占动态存储空间，函数调⽤结束后即释放）。
局部变量与全局变量区别栈、堆和静态存储区的区别
从作用域看：全局变量具有全局作用域.全局变量只需在一个源文件中定义，就可以作用于所有地源文件.当然，其他不包括全局变量定义地源文件需要用关键字再次声明这个全局变量.个人收集整理勿做商业用途静态局部变量具有局部作用域.它只被初始化一次，自从第一次初始化直到程序与你新内阁结束都一直存在，他和全局变量地区别在于全局变量对所有地函数都是可见地，而静态局部变量只对定义自己地函数体始终可见.个人收集整理勿做商业用途局部变量也只有局部作用域，他是自动对象，他在程序运行期间不是一直存在，而是只在函数执行期间存在，函数地一次调用结束后，变量就被撤销，其所占用地内存也被收回.个人收集整理勿做商业用途静态全局变量也具有全局作用域，他与全局变量地区别在于如果程序包含多个文件地话，他作用于定义它地文件里，不能作用到其他文件里，即被关键字修饰过地变量具有文件作用域.这样即使两个不同地源文件都定义了相同地静态全局变量，他们也是不同地变量.个人收集整理勿做商业用途从分配内存空间看：全局变量、静态局部变量、静态全局变量都在静态存储区分配空间，而局部变量在栈分配空间.全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式.这两者在存储方式上没有什么不同.区别在于非静态全局变量地作用域是整个源程序，当一个源程序由多个源文件组成时，非静态地全局变量在各个源文件中都是有效地.而静态全局变量则限制了其作用域，即只在定义该变量地源文件内有效，在同一源程序地其他源文件中不能使用它.由于静态全局变量地作用域局限于一个源文件内，只能为该源文件内地函数公用，因此可以避免在其他源文件中引起错误.个人收集整理勿做商业用途、静态变量会被放在程序地静态数据存储区里，这样可以在下一次调用地时候还可以保持原来地赋值.这一点是他与堆栈变量和堆变量地区别个人收集整理勿做商业用途、变量用告知编译器，自己仅仅在变量地作用域范围内可见.这一点是他与全局变量地区别.从以上分析可以看出，把局部变量改变为静态变量后是改变了他地存储方式，即改变了他地生存期.把全局变量改变为静态变量后是改变了他地作用域，限制了他地使用范围，因此这个说明符在不同地地方起地作用是不同地.个人收集整理勿做商业用途：、若全局变量仅在单个文件中访问，则可以讲这个变量修改为静态全局变量.、若全局变量仅在单个函数中使用，则可以将这个变量修改为该函数地静态局部变量.、全局变量、静态局部变量、静态全局变量都存放在静态数据存储区.、函数中必须要使用变量地情况：当某函数地返回值为指针类型时，则必须是地局部变量地地址作为返回值，若为类型，则返回为错指针.个人收集整理勿做商业用途个人收集整理勿做商业用途预备知识—程序地内存分配一个由编译地程序占用地内存分为以下几个部分栈区（）—由编译器自动分配释放，存放函数地参数值，局部变量地值等.其操作方式类似于数据结构中地栈. 个人收集整理勿做商业用途堆区（）—一般由程序员分配释放，若程序员不释放，程序结束时可能由回收 .注意它与数据结构中地堆是两回事，分配方式倒是类似于链表. 个人收集整理勿做商业用途全局区（静态区）（）—，全局变量和静态变量地存储是放在一块地，初始化地全局变量和静态变量在一块区域，未初始化地全局变量、未初始化地静态变量在相邻地另一块区域. 程序结束后有系统释放个人收集整理勿做商业用途文字常量区—常量字符串就是放在这里地.程序结束后由系统释放程序代码区—存放函数体地二进制代码.一个正常地程序在内存中通常分为程序段、数据端、堆栈三部分.程序段里放着程序地机器码、只读数据，这个段通常是只读，对它地写操作是非法地.数据段放地是程序中地静态数据.动态数据则通过堆栈来存放.个人收集整理勿做商业用途在内存中，它们地位置如下：内存低端程序段数据段堆栈内存高端个人收集整理勿做商业用途堆栈是内存中地一个连续地块.一个叫堆栈指针地寄存器（）指向堆栈地栈顶.堆栈地底部是一个固定地址.堆栈有一个特点就是，后进先出.也就是说，后放入地数据第一个取出.它支持两个操作，和.是将数据放到栈地顶端，是将栈顶地数据取出.在高级语言中，程序函数调用、函数中地临时变量都用到堆栈.为什么呢？因为在调用一个函数时，我们需要对当前地操作进行保护，也为了函数执行后，程序可以正确地找到地方继续执行，所以参数地传递和返回值也用到了堆栈.通常对局部变量地引用是通过给出它们对地偏移量来实现地.另外还有一个基址指针（，在芯片中是），许多编译器实际上是用它来引用本地变量和参数地.通常，参数地相对地偏移是正地，局部变量是负地.当程序中发生函数调用时，计算机做如下操作：首先把参数压入堆栈；然后保存指令寄存器()中地内容，做为返回地址()；第三个放入堆栈地是基址寄存器()；然后把当前地栈指针()拷贝到，做为新地基地址；最后为本地变量留出一定空间，把减去适当地数值.在函数体中定义地变量通常是在栈上，用, , 等分配内存地函数分配得到地就是在堆上.在所有函数体外定义地是全局量，加了修饰符后不管在哪里都存放在全局区（静态区），在所有函数体外定义地变量表示在该文件中有效，不能到别地文件用；在函数体内定义地表示只在该函数体内有效.另外，函数中地""这样地字符串存放在常量区.对比：个人收集整理勿做商业用途性能栈：栈存在于中.栈是动态地，它地存储速度是第二快地.堆：堆位于中，是一个通用地内存池.所有地对象都存储在堆中.申请方式【栈】: 由系统自动分配. 例如，声明在函数中一个局部变量; 系统自动在栈中为开辟空间 .【堆】: 需要程序员自己申请，并指明大小，在中函数如( *)(); 在中用运算符如( *)(); 但是注意：、本身是在栈中地.申请后系统地响应栈【】：只要栈地剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出. 个人收集整理勿做商业用途堆【】：首先应该知道操作系统有一个记录空闲内存地址地链表，当系统收到程序地申请时，会遍历该链表，寻找第一个空间大于所申请空间地堆结点，然后将该结点从空闲结点链表中删除，并将该结点地空间分配给程序；另外，对于大多数系统，会在这块内存空间中地首地址处记录本次分配地大小，这样，代码中地语句才能正确地释放本内存空间.另外，由于找到地堆结点地大小不一定正好等于申请地大小，系统会自动地将多余地那部分重新放入空闲链表中.申请大小地限制栈【】：在下，栈是向低地址扩展地数据结构，是一块连续地内存地区域.这句话地意思是栈顶地地址和栈地最大容量是系统预先规定好地，在下，栈地大小是（也有地说是，总之是一个编译时就确定地常数），如果申请地空间超过栈地剩余空间时，将提示.因此，能从栈获得地空间较小. 个人收集整理勿做商业用途堆【】：堆是向高地址扩展地数据结构，是不连续地内存区域.这是由于系统是用链表来存储地空闲内存地址地，自然是不连续地，而链表地遍历方向是由低地址向高地址.堆地大小受限于计算机系统中有效地虚拟内存.由此可见，堆获得地空间比较灵活，也比较大.申请效率地比较栈【】：由系统自动分配，速度较快.但程序员是无法控制地. 个人收集整理勿做商业用途堆【】：是由分配地内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便.另外，在下，最好地方式是用分配内存，他不是在堆，也不是在栈是直接在进程地地址空间中保留一快内存，虽然用起来最不方便.但是速度快，也最灵活.堆和栈中地存储内容栈【】：在函数调用时，第一个进栈地是主函数中后地下一条指令（函数调用语句地下一条可执行语句）地地址，然后是函数地各个参数，在大多数地编译器中，参数是由右往左入栈地，然后是函数中地局部变量.注意静态变量是不入栈地. 个人收集整理勿做商业用途当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存地地址，也就是主函数中地下一条指令，程序由该点继续运行.堆【】：一般是在堆地头部用一个字节存放堆地大小.堆中地具体内容有程序员安排.存取效率地比较[] "";* "";是在运行时刻赋值地；而是在编译时就确定地；但是，在以后地存取中，在栈上地数组比指针所指向地字符串(例如堆)快.比如：(){;[] "";* "";[];[];;}对应地汇编代码: [];[][]: [];[][][]第一种在读取时直接就把字符串中地元素读到寄存器中，而第二种则要先把指针值读到中，在根据读取字符，显然慢了.小结：堆和栈地区别可以用如下地比喻来看出：使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他地好处是快捷，但是自由度小.使用堆就象是自己动手做喜欢吃地菜肴，比较麻烦，但是比较符合自己地口味，而且自由度大.个人收集整理勿做商业用途。
内存中的五大区
2.生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
3.分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
00401035 mov eax，dword ptr [ebp-8]
00401038 mov dword ptr [ebp-4]，eax
这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。
4.分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
00401070 8A 42 01 mov al，byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4]，al
1.碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以>参考数据结构，这里我们就不再一一讨论了。
c语言中变量（存储区栈）和malloc（动态申请堆）的区别
c语言中变量（存储区栈）和malloc（动态申请堆）的区别
1、变量：
不管全局变量还市局部变量都是系统自动分配管理的（静态储存区和动态存储区即栈），全局变量如果不人工初始化时系统会自动初始化；对于静态局部变量，编译时自动赋初值初始化；自动局部变量不初始化，他的值是不确定的，因为每次函数调用结束后储存单元已经释放，下一次调用是又重新分配存储单元，而其中内存的内容是不知道的。
2、
malloc可以随时开辟，不用时随时释放。
这些数据是临时存放在一个特别的自用存储区，称其为堆。
由于未在声明部分定义他们为变量或数组，因此不能通过变量名或数组去引用这些数据包，只能通过指针来引用。
malloc分配出的空间不会被系统自动初始化，在使用前一定要初始化。
3、
在写程序时，一定不要把局部变量的地址作为函数的返回值。
一档尽量避免返回在函数内使用的分配函数（mnalloc或new）分配的内存空间，及使用malloc和free一定要成对的出现。
4、
malloc动态申请的空间，一直到它被释放为止，都是有效的。
5、
注意变量的作用域和存储期。
静态区-栈区-堆区区别
静态区：保存自动全局变量和 static 变量（包括 static 全局和局部变量）。
静态区的内容在总个程序的生命周期内都存在，由编译器在编译的时候分配。
堆：由 malloc 系列函数或 new 操作符分配的内存，其生命周期由 free 或 delete 决定。
在没有释放之前一直存在，直到程序结束，其特点是使用灵活，空间比较大，但容易出错栈：保存局部变量，栈上的内容只在函数的范围内存在，当函数运行结束，这些内容也会自动被销毁，其特点是效率高，但空间大小有限例子：Code:#include <stdio.h>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" 优化成一个地方。
}再来看下各个生命周期：外部变量 = 全局变量作用域：从定义处到源文件结束生命周期：从程序执行开始 - 程序执行结束局部变量作用域：函数（复合语句）内部生命周期：从函数调用开始 - 函数调用结束static 局部变量作用域：同局部变量生命周期：同外部变量static 全局变量作用域：被编译文件的剩余部分生命周期：同全局变量当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。
栈区,堆区,全局区,文字常量区,程序代码区
栈区，堆区，全局区，文字常量区，程序代码区内存管理（1）一、预备知识—程序的内存分配一个由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 = new char[10];但是注意p1、p2本身是在栈中的。
C语言内存管理堆栈和静态存储区
C语言内存管理堆栈和静态存储区C语言内存管理：堆、栈和静态存储区C语言作为一种高效而强大的编程语言，其内存管理是程序员必须掌握的重要内容之一。
本文将重点介绍C语言中的内存管理中的堆、栈以及静态存储区。
一、堆堆是C语言中用于动态内存分配的一块内存区域。
在程序运行时，可以通过函数malloc()和calloc()来申请堆空间，通过函数free()来释放堆空间。
堆的特点：1. 大小可变：堆中的内存空间大小可以在程序运行时进行动态调整。
2. 生命周期自由控制：通过malloc()或calloc()分配的堆空间，在不再使用后，需要程序员手动调用free()函数进行释放。
堆的使用场景：1. 动态数组：当程序无法预先知道数组大小时，可以使用堆来动态申请空间。
2. 链表：链表结构通常需要通过堆来进行动态内存分配。
二、栈栈是C语言中用于函数调用和局部变量存储的一块内存区域。
在函数调用过程中，栈会记录函数的调用顺序、调用参数以及局部变量等。
栈的特点：1. 后进先出：栈是一种后进先出（LIFO）的数据结构，函数调用时会依次将函数入栈，并在函数返回时依次出栈。
2. 自动管理：栈内存的分配和释放是由编译器自动完成的，程序员无需手动管理。
栈的使用场景：1. 函数调用：栈用于管理函数的调用顺序以及函数内部的局部变量。
2. 递归：递归函数的调用过程涉及到栈的递归压栈和递归出栈。
三、静态存储区静态存储区是C语言中使用static关键字声明的变量所存储的内存区域。
在程序运行期间，静态变量在内存中的位置始终不变，且仅在程序结束时才会释放。
静态存储区的特点：1. 生命周期长：静态变量在程序运行期间都存在，不依赖于函数的调用和返回。
2. 全局可访问：静态变量可以在整个程序中被访问，不受函数作用域的限制。
静态存储区的使用场景：1. 全局变量：使用static关键字声明的全局变量存储在静态存储区中，可以在整个程序中被访问。
2. 共享数据：多个函数之间需要共享的数据可以使用静态变量来实现。
栈和堆的概念
栈和堆的概念1.引言在计算机科学中，栈和堆是两个常见的数据结构和内存管理概念。
它们在程序执行、变量分配和内存管理方面起着重要作用。
本文将介绍栈和堆的概念，并探讨它们的特点和应用。
2.栈的概念2.1定义栈（Stack）是一种后进先出（Last In First Out，LIFO）的数据结构。
它类似于现实生活中的一叠盘子，只能在最顶层进行操作。
栈具有两个基本操作：入栈（Push）和出栈（Pop）。
入栈将元素放入栈的顶部，出栈则从栈的顶部移除元素。
2.2特点-后进先出：栈中最后进入的元素将首先被移除。
-有限容量：栈的容量有限，当栈已满时无法再进行入栈操作。
-快速访问：由于栈的特殊结构，对于栈中的元素可以快速进行访问和操作。
2.3应用-函数调用：在函数调用过程中，局部变量和函数参数被存储在栈中。
每次函数调用时，相关的数据被压入栈中，函数返回时再从栈中弹出。
-表达式求值：在数学表达式求值过程中，栈常被用于保存运算符和操作数的顺序。
-递归算法：递归算法通常使用栈来保存每一层递归的状态。
3.堆的概念3.1定义堆（Heap）是一种动态内存分配方式，也是一种数据结构。
堆的内存空间可以在程序运行时进行动态分配和释放。
与栈不同，堆的数据访问没有限制顺序，可以任意读取或写入堆中的数据。
3.2特点-动态分配：堆的内存空间可以在程序运行时动态分配，而不受固定容量的限制。
-无序性：堆中的数据可以以任意顺序进行读写，没有先进先出或后进先出的限制。
-存储复杂的数据结构：由于堆的灵活性，它可以存储复杂的数据结构，如树、图等。
3.3应用-动态内存分配：堆经常用于动态分配内存空间，例如在编程中使用new或malloc函数来动态创建对象或数组。
-数据库管理：数据库中的数据通常存储在堆中，以便在需要时进行动态增加或删除。
-图形处理：堆经常用于图形处理算法，如最短路径、最小生成树等。
4.栈和堆的区别4.1分配方式栈的分配方式是静态的，大小固定，并且由编译器自动管理。
C++中堆和栈的完全解析
C++中堆和栈的完全解析内存分配方面：堆：操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样代码中的delete语句才能正确的释放本内存空间。
我们常说的内存泄露，最常见的就是堆泄露（还有资源泄露），它是指程序在运行中出现泄露，如果程序被关闭掉的话，操作系统会帮助释放泄露的内存。
栈：在函数调用时第一个进栈的主函数中的下一条指令（函数调用语句的下一条可执行语句）的地址然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈，然后是函数中的局部变量。
一、预备知识—程序的内存分配一个由c/C++编译的程序占用的内存分为以下几个部分1、栈区（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。
其操作方式类似于数据结构中的栈。
2、堆区（heap）—一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
- 程序结束后有系统释放4、文字常量区—常量字符串就是放在这里的。
程序结束后由系统释放5、程序代码区—存放函数体的二进制代码。
有些说法，把3，4合在一起，也有的把3分成自由存储区（malloc/free）和全局/静态存储区。
这与编译器和操作系统有关。
二、例子程序这是一个前辈写的，非常详细//main.cppint a = 0; 全局初始化区char *p1; 全局未初始化区main(){int b; 栈char s[] = "abc"; 栈//更正：abc 分配在静态存储区，不是栈上char *p2; 栈char *p3 = "123456"; 123456\0在常量区，p3在栈上。
全局变量、成员变量、类变量、静态变量、实例变量、局部变量的定义与区别
全局变量、成员变量、类变量、静态变量、实例变量、局部变量的定义与区别private int i;//实例变量private static int j;//类变量实例变量总是通过对象来访问，因为它们的值在对象和对象之间有所不同。
⽽由static修饰的类变量(静态变量)在类装载的时候就会被初始化,也就是说⼀处修改多处改变.局部变量⽅法内定义的变量叫局部变量，因为只能在⽅法内部使⽤，固不可以⽤private，public，protect来修饰。
{int k;//局部变量}类变量类变量：⼜叫静态变量⽤static修饰它可以直接⽤类名调⽤也可以⽤对象调⽤⽽且所有对象的同⼀个类变量都是共享同⼀块内存空间的.实例变量实例变量：不⽤static修饰它只能通过对象调⽤⽽且所有对象的同⼀个实例变量是共享不同的内存空间的.下⾯是它们之间的思维导图关系。
全局变量和局部变量的区别全局变量：1、成员变量定义在类中，在整个类中都可以被访问。
2、成员变量随着对象的建⽴⽽建⽴，随着对象的消失⽽消失，存在于对象所在的堆内存中。
(实例变量)3、成员变量有默认初始化值。
局部变量：1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。
2、局部变量存在于栈内存中，作⽤的范围结束，变量空间会⾃动释放。
3、局部变量没有默认初始化值实例变量和类变量的区别1、两个变量的⽣命周期不同实例变量随着对象的创建⽽存在，随着对象的回收⽽释放。
静态变量随着类的加载⽽存在，随着类的消失⽽消失。
2、调⽤⽅式不同实例变量只能被对象调⽤。
静态变量可以被对象调⽤，还可以被类名调⽤。
3、数据存储位置不同实例变量存储在堆内存的对象中，所以也叫对象的特有数据。
静态变量数据存储在⽅法区（共享数据区）的静态区，所以也叫对象的共享数据。
局部变量、全局变量、堆、堆栈、静态和全局变量
局部变量、全局变量、堆、堆栈、静态和全局变量一般全局变量存放在数据区，局部变量存放在栈区，动态变量存放在堆区，函数代码放在代码区。
---------------------------------------------------------------栈区是普通的栈数据结构,遵循LIFO后进先出的规则,局部变量安排在那里是ASM时就规定的,这样可以在一个函数结束后平衡堆栈,操作简单,效率高堆(动态区)在这里应当叫堆栈(不要和数据结构中的堆搞混)是程序在编译时产生的一块用于产生动态内存分配使用的块,操作比较栈要麻烦许多,在分配时要判断最优的地址(防止产生无用的内存碎片(由于屡次的NEW和DELETE产生的夹在两块使用中内存中的空余小内存(不容易被分配))),分配和回收时的效率比栈低多了---------------------------------------------------------------栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而堆是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率>有一定降低。
栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。
不同堆分配的内存无法互相操作。
栈空间分静态分配和动态分配两种。
静态分配是编译器完成的，比如自动变量(auto)的分配。
动态分配由malloca函数完成。
栈的动态分配无需释放(是自动的)，也就没有释放函数。
为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/ 释放内存匹>配是良好程序的基本要素。
堆是程序员管理的,栈是系统管理的.另外关于静态和全局的一些问题：静态变量的特点：1、一次存储：静态局部变量只被初始化一次，下一次初始化根据上一次的结果值，有点类似于c++中类的静态成员变量，即无论该类型生成多少个实例对象，所有的对象共用一个静态变量，到这里就是无论这个函数调用多少次，该静态变量只初始化一次，并没有因为超出其生存期而被销毁，只是外部不可见而已，用个例子说明之：void fun1( int v ){static int value = v;static int value = v;}int main( int arc, char*args[ ]){fun1( 50 );fun1( 100 );}执行的结果是：value : 50 value : 50说明在第二次调用fun1( )时的初始化value的采用的是上一次value的值，value在静态区的存储空间并没有因为fun1( )的结束而被释放，即体现了一次存储；2、作用域限定：静态修饰的作用域限定功能同时体现在函数与变量上；a)对于函数而言，任何用static修饰的函数，其作用域仅为当前源文件，而对外部来说这个函数是不可见的，即只有和其在同一源文件中的函数才能调用这个静态函数；反过来说，如果一个函数仅仅被同一源文件中的其他函数调用，那么这个函数应该声明为静态的，这样做的好处在于：可以一定程度上的解决不同源文件之间函数的命名冲突问题；b)对于变量而言，static修饰的全局变量，只在当前源文件中有效，对外部不可见，外部文件不能够引用；顾名思义，全局变量是指能够在全局引用的变量，相对于局部变量的概念，也叫外部变量；同静态变量一样，全局变量位于静态数据区，全局变量一处定义，多处引用，用关键字“extern”引用“外部”的变量。
变量与常量在内存中的存储方式有哪些
变量与常量在内存中的存储方式有哪些在计算机编程中，变量和常量是非常基础的概念。
它们在程序中用于存储数据，并且在内存中有不同的存储方式。
本文将介绍变量和常量在内存中的存储方式。
一、变量的存储方式变量是用于存储可变数据的一种标识符。
在编程中，我们可以为变量分配内存空间，并将数据存储在这个空间中。
变量的存储方式主要有以下几种：1. 栈内存存储栈内存是一种后进先出（LIFO）的数据结构，用于存储局部变量和函数的参数。
当一个函数被调用时，它的参数和局部变量将被分配在栈内存中。
当函数执行完毕后，这些变量将被自动释放。
栈内存的优点是分配和释放速度快，但是它的大小有限，超出限制可能导致栈溢出。
2. 堆内存存储堆内存是一种动态分配的内存空间，用于存储动态创建的变量。
在堆内存中，变量的生命周期由程序员手动管理，需要手动分配内存空间，并在不需要时手动释放。
堆内存的优点是大小不受限制，但是分配和释放速度较慢，容易产生内存泄漏。
3. 全局内存存储全局内存是在程序运行时就被分配的内存空间，用于存储全局变量和静态变量。
全局变量在程序的任何地方都可以访问，生命周期会持续到程序结束。
全局内存的优点是方便共享和访问，但是会增加内存的使用量。
二、常量的存储方式常量是指在程序中固定不变的值。
与变量不同，常量的值在程序运行时是无法修改的。
常量的存储方式主要有以下几种：1. 文字常量存储文字常量是指在程序中直接使用的字符串或字符。
这些常量通常存储在只读内存区域，以确保其值不会被修改。
文字常量的存储方式可以提高程序的性能，因为它们只需要在内存中存储一份副本。
2. 符号常量存储符号常量是指在程序中使用#define或const关键字定义的常量。
这些常量通常存储在静态存储区域，并在程序运行时被初始化。
符号常量的存储方式可以提高程序的可读性和可维护性，因为它们可以在程序中多次使用，并且只需要在内存中存储一份副本。
3. 枚举常量存储枚举常量是指在程序中使用enum关键字定义的常量。
全局变量的内存分配方式
全局变量的内存分配方式
全局变量的内存分配方式
1. 静态分配：静态分配是指在编译期间分配给变量一段内存，编译器
就可以在编译时分配内存，当程序运行时，该变量的内存空间仍为编
译期间分配的空间。
静态分配的全局变量可以在所有函数内共享，但
它们在程序结束后仍然占用系统资源，不会被释放掉。
2. 动态分配：动态分配的全局变量是当程序运行时动态分配内存的，
当程序不再使用该变量时，可以调用C标准库中提供的free函数来释
放内存，这样在程序结束时就不会再占用系统资源了。
3. 堆分配：堆分配的全局变量在程序运行后，分配在进程的堆内存中，这些变量的数量可以根据程序的需求变化，它可以由malloc或calloc
函数分配，也可以由realloc函数复制或改变大小，释放内存也是由
free函数完成。
4. 共享内存分配：共享内存分配的全局变量与进程间分配的共享内存
挂钩，这种变量可以被多个进程访问，而各个进程也可以更新该变量，例如，你可以在一个进程中修改全局变量的值，更改后的值会反映到
主进程中。
5. 寄存器分配：寄存器分配的全局变量被储存在处理器的通用寄存器
里，这类型的变量不会被写入内存，所以可以获得高效的访问速度，但是由于寄存器数量有限，因此只能分配少量全局变量。
总结：全局变量的内存分配方式有静态分配、动态分配、堆分配、共享内存分配和寄存器分配等，各种内存分配方式的特点及使用方法各有不同，用户根据自己的特定需求来选择最合适的内存分配方式。
dui堆和zhan栈的区别
堆是随机存放的但是栈却是只能够先进后出int a,b;int n=10;int func(){int m=10;a=m*3;b=n*3;return 0;}int main(){fumc();return 0;}在C++中,内存分成4个区,他们分别是堆,栈,静态存储区和常量存储区1)栈,就是那些由编译器在需要的时候分配,在不需要的时候自动清除的变量的存储区.里面的变量通常是局部变量,函数参数等.2)堆,又叫自由存储区,它是在程序执行的过程中动态分配的,它最大的特性就是动.态性.由new分配的内存块,他们的释放编译器不去管,由我们的应用程序去控制,一般一个new就要对应一个delete.如果程序员没有释放掉,那么在程序结束后,操作系统会自动回收.如果分配了堆对象,却忘记了释放,就会产生内存泄漏.而如果已释放了对象,却没有将相应的指针置为NULL,该指针就是"悬挂指针".4)静态存储区.所有的静态对象,全局对象都于静态存储区分配.5)常量存储区,这是一块比较特殊的存储区,他们里面存放的是常量,不允许修改(当然,你要通过非正当手段也可以修改,而且方法很多)常量字符串都存放在静态存储区,返回的是常量字符串的首地址.n是全局变量,储存在静态区.进入main函数之前就被创建.生命周期为整个源程序.m是局部变量,在栈中分配.在函数func被调用时才被创建.生命周期为函数func内.n只创建一次.m每次调用func都会创建,函数结束就销毁.在pc上面堆是从上往下的栈是从下往上的数据段存放全局变量静态变量和常量和malloc申请的的动态空间（堆）就是堆代码段存着程序代码堆栈段存着子程序的返回地址子程序入口参数和程序的局部变量就是栈静态变量和全局变量，malloc申请的动态内存空间，一般都是存放在堆中栈中存放的是子函数入口的临时变量或局部变量摘自Thinking in java第一版===========================2.2.1 保存到什么地方程序运行时，我们最好对数据保存到什么地方做到心中有数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
堆与栈，静态变量和全局变量的区别
堆与栈，静态变量和全局变量的区别
对和栈的主要的区别由以下几点：
1、管理方式不同；
2、空间大小不同；
3、能否产生碎片不同；
4、生长方向不同；
5、分配方式不同；
6、分配效率不同；
管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。
但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。
当然，我们可以修改：
打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。
注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。
碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。
对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构，这里我们就不再一一讨论了。
生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
分配方式：堆都是动态分配的，没有静态分配的堆。
栈有2种分配方式：静态分配和动态分配。
静态分配是编译器完成的，比如局部变量的分配。
动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。
堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。
显然，堆的效率比栈要低得多。
从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。
所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP 和局部变量都采用栈的方式存放。
所以，我们推荐大家尽量用栈，而不是用堆。
栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大量的
内存空间，还是用堆好一些。
无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，
说不定什么时候就崩掉，那时候debug可是相当困难的：）
对了，还有一件事，如果有人把堆栈合起来说，那它的意思是栈，可不是堆，呵呵，清楚了？
全局变量和静态全局变量的区别
全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。
这两者在存储方式上并无不同。
这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。
而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。
由于静态全局变量的作用
域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。
从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即
改变了它的生存期。
把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。
因此static 这个说明符在不同的地方所起的作用是不同的。
应予以注意。
Static
1. 静态变量，分配在静态存储区，在数据段中。
函数退出之后，变量值不变。
2. 作用域，全局的静态变量、静态函数只能在本文件中使用。
（不同于一般
全局变量）
局部的静态变量同函数的局部变量
2，结构体和联合体的区别，
结构体是根据所有元素所占的内存空间的总和来为其分配存储空间
联合体是根据占内存空间最大的那个元素来为其分配存储空间。