内存区划分、内存分配、常量存储区、堆、栈、自由存储区、全局区[C ][内存管理]
C C++语言变量声明内存分配
C/C++语言变量声明内存分配2010-11-08 07:10:20| 分类：编程|字号订阅一个由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/0"在常量区，p3在栈上。
static int c =0；//全局（静态）初始化区p1 = (char *)malloc(10);p2 = (char *)malloc(20);//分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); //123456/0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}===============C语言程序的内存分配方式1.内存分配方式内存分配方式有三种：[1]从静态存储区域分配。
c++内存分配机制
C++的内存分配机制可以分为四个区域：堆区、栈区、全局/静态存储区和常量存储区。
1. 堆区：动态内存分配区，程序在运行时可以向该区域申请一定大小的内存，用malloc或new来申请，用free或delete来释放。
2. 栈区：存放函数的参数值和局部变量，由编译器自动分配和释放，其操作方式类似于数据结构中的栈。
3. 全局/静态存储区：全局变量和静态变量被存放在此区域中，包括初始化的全局变量和静态变量（空白初始化的全局变量和静态变量也会被存放在此区域），全局变量和静态变量在程序整个运行期间一直被保留。
4. 常量存储区：常量被存放在此区域中，不允许修改。
C++内存分配机制遵循二八定律，即80%的内存空间被80%的程序所使用，而剩下的20%的内存空间则被浪费。
因此，在编写C++程序时，应该尽可能地利用好内存空间，避免内存空间的浪费。
单片机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 信息去进行释放内存的工作。
内存泄漏和内存溢出、堆内存和栈内存区分、负载标准、降低cache内存方法
（一）内存泄漏和内存溢出内存溢出 out of memory，是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。
内存溢出就是你要求分配的内存超出了系统能给你的，系统不能满足需求，于是产生溢出。
内存泄露 memory leak，是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光。
内存泄漏是指你向系统申请分配内存进行使用(new)，可是使用完了以后却不归还(delete)，结果你申请到的那块内存你自己也不能再访问（也许你把它的地址给弄丢了），而系统也不能再次将它分配给需要的程序。
memory leak会最终会导致out of memory。
（二）堆内存和栈内存区分一、数据结构中的堆和栈1. 栈是一种连续储存的数据结构，具有先进后出的性质。
通常的操作有入栈（压栈），出栈和栈顶元素。
想要读取栈中的某个元素，就是将其之间的所有元素出栈才能完成。
2. 堆是一种非连续的树形储存数据结构，每个节点有一个值，整棵树是经过排序的。
特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。
常用来实现优先队列，存取随意。
二、内存中的栈区与堆区1. 内存中的栈区与堆区比较2. 计算机内存的大致划分一般说到内存，指的是计算机的随机存储器（RAM），程序都是在这里面运行。
三、栈内存与栈溢出由程序自动向操作系统申请分配以及回收，速度快，使用方便，但程序员无法控制。
若分配失败，则提示栈溢出错误。
注意，const 局部变量也储存在栈区内，栈区向地址减小的方向增长。
四、堆内存与内存泄露程序员向操作系统申请一块内存，当系统收到程序的申请时，会遍历一个记录空闲内存地址的链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。
内存分配方式范文
内存分配方式范文内存分配是计算机中的重要概念，它指的是将计算机的内存资源分配给不同的程序和数据。
内存分配方式可以根据分配的策略和实现方式来进行分类。
下面将介绍几种常见的内存分配方式。
1.静态分配：静态分配是指在编译或链接阶段将内存空间分配给程序的变量或数据结构。
在静态分配中，内存的分配和释放是由编译器或链接器完成的，程序在运行期间不会改变内存分配的情况。
静态分配的优点是分配速度快，不会发生内存碎片问题，但缺点是需要预先确定内存的大小，不能动态调整。
2.动态分配：动态分配是在程序运行期间根据需要分配和释放内存空间。
常见的动态分配方式有以下几种：- 堆（Heap）分配：堆分配是通过指定大小在堆内存中分配一块连续的内存空间。
它通常用于创建动态分配的数据结构，如链表、树、堆等。
堆分配的优点是可以根据需要分配灵活大小的内存，但缺点是分配和释放的速度较慢，并且容易产生内存碎片。
- 栈（Stack）分配：栈分配是指在程序运行期间分配局部变量和函数调用的内存空间。
栈内存具有后进先出的特性，每次分配内存只需要修改栈指针即可。
栈分配的优点是分配和释放速度快，但缺点是分配的内存大小固定，不适合动态分配。
- 池（Pool）分配：池分配是指事先在内存中创建一定数量的内存块，然后根据需要从池中分配和释放内存。
池分配的优点是分配和释放速度快，且不容易产生内存碎片，但缺点是需要事先确定池的大小，不能动态调整。
3.分区分配：分区分配是指将内存空间分成多个固定大小的分区，每个分区用于分配给不同的程序或数据。
常见的分区分配方式有以下几种：-等大小分区：等大小分区是将内存空间分成大小相等的分区，每个分区只能分配给一个程序或数据。
这种分区方式容易产生内存碎片，但分配和释放速度较快。
-不等大小分区：不等大小分区是将内存空间分成大小不等的分区，每个分区可以根据需要分配给不同大小的程序或数据。
这种分区方式可以更有效地利用内存空间，但分配和释放速度较慢。
内存中堆栈的划分
栈和堆的区别 (转) 终于知道区别了(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 。
C语言内存分配问题(整理)
我查了下资料，有说分四个，有说分五个加一个程序代码区，我没查到参考的专业书籍。所 以麻烦知道的告知一下，完善一下。
2、 内存分配方式 内存分配方式有三种：
1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整 个运行期间都存在。例如全局变量，static 变量。
4、动态分配释放内存举例 用 malloc 动态分配内存后一定要判断一下分配是否成功，判断指针的值是否为 NULL。 内存分配成功后要对内存单元进行初始化。 内存分配成功且初始化后使用时别越界了。 内存使用完后要用 free（p）释放，注意，释放后，p 的值是不会变的，仍然是一个地址值， 仍然指向那块内存区，只是这块内存区的值变成垃圾了。为了防止后面继续使用这块内存， 应在 free(p)后，立即 p=NULL，这样后面如果要使用，判断 p 是否为 NULL 时就会判断出 来。
NO.2
char *GetMemory(void) {
char Байду номын сангаас[] = hello world; retrun p; } void Test(void) { char *str = NULL; str = GetMemory(); printf(str); }
问题同 NO.1
NO.3
void GetMemory(char **p, int num) {
free(str); if(str != NULL) {
strcpy(str,"world"); printf(str); } }
问题同 NO.1 我对以上问题的分析：
NO.1：程序首先申请一个 char 类型的指针 str,并把 str 指向 NULL（即 str 里存的是 NULL 的地址，*str 为 NULL 中的值为０），调用函数的过程中做了如下动作： 1、申请一个 char 类型的指针 p， 2、把 str 的内容 copy 到了 p 里（这是参数传递过程中系统所做的）, 3、为 p 指针申请了 100 个空间， 4、返回 Test 函数．最后程序把字符串 hello world 拷贝到 str 指向的内存空间里．到这里错 误出现了！ str 的空间始终为 NULL 而并没有实际的空间．深刻理解函数调用的第 2 步，将不难发现问 题所在！（注意：传递的参数和消除的参数） NO.2：程序首先申请一个 char 类型的指针 str,并把 str 指向 NULL．调用函数的过程中做了 如下动作： １申请一数组 p[]并将其赋值为 hello world(数组的空间大小为 12)， ２返回数组名 p 付给 str 指针（即返回了数组的首地址）． 那么这样就可以打印出字符串＂hello world＂了么？当然是不能的！ 因为在函数调用的时候漏掉了最后一步．也就是在第２步 return 数组名后，函数调用还要 进行一步操作，也就是释放内存空间．当一个函数被调用结束后它会释放掉它里面所有的变 量所占用的空间．所以数组空间被释放掉了，也就是说 str 所指向的内容将不确定是什么东 西． NO.3：正确答案为可以打印出 hello．但内存泄漏了！ 需要用 free（）函数进行释放。
内存中的五大区
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语言的内存分配详解
堆内存的分配与释放
堆空间申请、释放的方法
在C++中，申请和释放堆中分配的存贮空间， 中 申请和释放堆中分配的存贮空间， 分别使用new和delete的两个运算符来完成： 分别使用 和 的两个运算符来完成： 的两个运算符来完成 指针变量名=new 类型名 初始化式 ； 类型名(初始化式 初始化式)； 指针变量名 delete 指针名 指针名; 例如： 例如：1、 int *pi=new int(0); 它与下列代码序列大体等价： 它与下列代码序列大体等价： 2、int ival=0, *pi=&ival; 区别：pi所指向的变量是由库操作符new()分配的 所指向的变量是由库操作符new()分配的， 区别：pi所指向的变量是由库操作符new()分配的， 位于程序的堆区中，并且该对象未命名 该对象未命名。 位于程序的堆区中，并且该对象未命名。
堆的概念
通常定义变量（或对象），编译器在编译时都可 通常定义变量（或对象），编译器在编译时都可 ）， 以根据该变量（或对象）的类型知道所需内存空间的大小， 以根据该变量（或对象）的类型知道所需内存空间的大小，从 而系统在适当的时候为他们分配确定的存储空间。 而系统在适当的时候为他们分配确定的存储空间。这种内存分 配称为静态存储分配 静态存储分配； 配称为静态存储分配； 有些操作对象只在程序运行时才能确定， 有些操作对象只在程序运行时才能确定，这样编译时就 无法为他们预定存储空间，只能在程序运行时， 无法为他们预定存储空间，只能在程序运行时，系统根据运行 时的要求进行内存分配，这种方法称为动态存储分配 动态存储分配。 时的要求进行内存分配，这种方法称为动态存储分配。所有动 态存储分配都在堆区中进行。 态存储分配都在堆区中进行。 当程序运行到需要一个动态分配的变量或对象时， 当程序运行到需要一个动态分配的变量或对象时，必须 向系统申请取得堆中的一块所需大小的存贮空间， 申请取得堆中的一块所需大小的存贮空间 向系统申请取得堆中的一块所需大小的存贮空间，用于存贮该 变量或对象。当不再使用该变量或对象时， 变量或对象。当不再使用该变量或对象时，也就是它的生命结 束时， 显式释放它所占用的存贮空间 它所占用的存贮空间， 束时，要显式释放它所占用的存贮空间，这样系统就能对该堆 空间进行再次分配，做到重复使用有限的资源。 空间进行再次分配，做到重复使用有限的资源。
c语言中内存分配的几种方式
c语言中内存分配的几种方式
在C语言中，内存的管理是非常重要的。
C语言提供了多种内存分配的方式，可以根据不同情况选择不同的方式进行内存分配。
以下是C语言中内存分配的几种方式。
1. 静态内存分配
静态内存分配是在程序编译时就确定了内存的大小和分配位置，这种方式不需要在程序运行时进行内存分配。
在C语言中，静态内存分配可以通过定义全局变量或静态变量来实现。
2. 栈内存分配
栈内存分配是指在函数内部定义的变量所分配的内存。
当函数被调用时，栈被分配一段内存用来存储函数的局部变量，当函数返回时，这段内存会被释放。
栈内存分配的好处是速度快，但是分配的内存大小受限于栈的大小。
3. 堆内存分配
堆内存分配是指程序在运行时通过malloc()函数或calloc()函数动态分配内存。
堆内存的好处是大小灵活，但是需要手动释放，否则容易出现内存泄漏的问题。
4. 内存映射文件
内存映射文件是指将一个文件映射到内存中，使得程序可以直接访问文件中的数据。
在C语言中，可以使用mmap()函数将文件映射到内存中。
总结
在C语言中，内存的管理是非常重要的。
根据不同的情况可以选择不同的内存分配方式，如静态内存分配、栈内存分配、堆内存分配和内存映射文件等。
合理的内存管理可以提高程序的性能和稳定性。
C++核心编程思维导图,脑图
C++核心编程1 内存分区模型代码区：存放函数体的二进制代码，由操作系统进行管理的全局区：存放全局变量和静态变量以及常量栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收1.1 程序运行前C++中在程序运行前分为全局区和代码区代码区特点是共享和只读全局区中存放全局变量、静态变量、常量常量区中存放 const修饰的全局常量 和 字符串常量1.2 程序运行后1.3 new操作符2 引用2.1 引用的基本使用2.2 引用注意事项引用必须初始化引用在初始化后，不可以改变2.3 引用做函数参数2.4 引用做函数返回值2.5 引用的本质2.6 常量引用3 函数提高3.1 函数默认参数3.2 函数占位参数3.3 函数重载3.3.1 函数重载概述同一个作用域下函数名称相同函数参数**类型不同** 或者 **个数不同** 或者 **顺序不同**3.3.2 函数重载注意事项引用作为重载条件函数重载碰到函数默认参数**4** 类和对象4.1 封装4.1.1 封装的意义将属性和行为加以权限控制1. public 公共权限2. protected 保护权限3. private 私有权限4.1.2 struct和class区别struct 默认权限为公共class 默认权限为私有4.1.3 成员属性设置为私有4.2 对象的初始化和清理生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全将属性和行为作为一个整体，表现生活中的事物C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置。
4.2.1 构造函数和析构函数构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
析构函数：主要作用在于对象**销毁前**系统自动调用，执行一些清理工作。
1. 构造函数，没有返回值也不写void2. 函数名称与类名相同3. 构造函数可以有参数，因此可以发生重载4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次1. 析构函数，没有返回值也不写void2. 函数名称与类名相同,在名称前加上符号 ~3. 析构函数不可以有参数，因此不可以发生重载4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次4.2.2 构造函数的分类及调用4.2.3 拷贝构造函数调用时机使用一个已经创建完毕的对象来初始化一个新对象值传递的方式给函数参数传值以值方式返回局部对象4.2.4 构造函数调用规则如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造如果用户定义拷贝构造函数，c++不会再提供其他构造函数4.2.5 深拷贝与浅拷贝4.2.6 初始化列表4.2.7 类对象作为类成员4.2.8 静态成员静态成员变量所有对象共享同一份数据在编译阶段分配内存类内声明，类外初始化静态成员函数所有对象共享同一个函数静态成员函数只能访问静态成员变量4.3 C++对象模型和this指针4.3.1 成员变量和成员函数分开存储4.3.2 this指针概念当形参和成员变量同名时，可用this指针来区分在类的非静态成员函数中返回对象本身，可使用return *this4.3.3 空指针访问成员函数4.3.4 const修饰成员函数成员函数后加const后我们称为这个函数为**常函数**常函数内不可以修改成员属性成员属性声明时加关键字mutable后，在常函数中依然可以修改声明对象前加const称该对象为常对象常对象只能调用常函数4.4 友元全局函数做友元类做友元成员函数做友元4.4.1 全局函数做友元4.4.2 类做友元4.4.3 成员函数做友元4.5 运算符重载4.5.1 加号运算符重载4.5.2 左移运算符重载4.5.3 递增运算符重载4.5.4 赋值运算符重载1. 默认构造函数(无参，函数体为空)2. 默认析构函数(无参，函数体为空)3. 默认拷贝构造函数，对属性进行值拷贝4. 赋值运算符 operator=, 对属性进行值拷贝4.5.5 关系运算符重载4.5.6 函数调用运算符重载函数调用运算符 () 也可以重载由于重载后使用的方式非常像函数的调用，因此称为仿函数仿函数没有固定写法，非常灵活4.6 继承4.6.1 继承的基本语法4.6.2 继承方式公共继承保护继承私有继承4.6.3 继承中的对象模型4.6.4 继承中构造和析构顺序4.6.5 继承同名成员处理方式访问子类同名成员 直接访问即可访问父类同名成员 需要加作用域1. 子类对象可以直接访问到子类中同名成员2. 子类对象加作用域可以访问到父类同名成员3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数4.6.6 继承同名静态成员处理方式访问子类同名成员 直接访问即可访问父类同名成员 需要加作用域4.6.7 多继承语法4.6.8 菱形继承1. ``` null羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
栈区,堆区,全局区,文字常量区,程序代码区
栈区，堆区，全局区，文字常量区，程序代码区内存管理（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. 共享数据：多个函数之间需要共享的数据可以使用静态变量来实现。
C语言经典面试题目及答案详解(三)
C语言经典面试题目及答案详解（三）接着更新C语言面试题，希望能帮助到大家！1、变量的声明和定义有什么区别为变量分配地址和存储空间的称为定义，不分配地址的称为声明。
一个变量可以在多个地方声明，但是只在一个地方定义。
加入 extern 修饰的是变量的声明，说明此变量将在文件以外或在文件后面部分定义。
说明：很多时候一个变量，只是声明不分配内存空间，直到具体使用时才初始化，分配内存空间，如外部变量。
2、写出 bool 、int、 float、指针变量与“零值”比较的if 语句bool 型数据： if( flag ) {A; } else {B； } int 型数据： if( 0 != flag ) {A; } else {B； }指针型数： if( NULL == flag ) {A; } else {B； } float 型数据： if ( ( flag >= NORM ) && ( flag <= NORM ) ) {A； }注意：应特别注意在 int、指针型变量和“零值”比较的时候，把“零值”放在左边，这样当把“==”误写成“=”时，编译器可以报错，否则这种逻辑错误不容易发现，并且可能导致很严重的后果。
3、sizeof 和 strlen 的区别sizeof 和 strlen 有以下区别：1. sizeof 是一个操作符，strlen 是库函数。
2. sizeof 的参数可以是数据的类型，也可以是变量，而strlen 只能以结尾为‘\0‘的字符串作参数。
3. 编译器在编译时就计算出了 sizeof 的结果。
而 strlen 函数必须在运行时才能计算出来。
并且 sizeof 计算的是数据类型占内存的大小，而 strlen 计算的是字符串实际的长度。
4. 数组做 sizeof 的参数不退化，传递给 strlen 就退化为指针了。
注意：有些是操作符看起来像是函数，而有些函数名看起来又像操作符，这类容易混淆的名称一定要加以区分，否则遇到数组名这类特殊数据类型作参数时就很容易出错。
c语言指针面试常见问题及解析
c语言指针面试常见问题及解析c语言指针面试常见问题及解析分析下面的程序,指出程序中的错误：本题解析没有正确为str分配内存空间，将会发生异常。
问题出在将一个字符串复制进一个字符变量指针所指地址。
虽然编译的时候没有报错，但是在运行过程中，因为越界访问了未被分配的内存，而导致段错误。
相关知识点在处理与指针相关的问题时，首先需要搞明白的就是内存，因为指针操作的就是内存。
第一个，就是内存的分区。
这也是经常会被考察的一个考点。
写出内存分为几大区域对于这个问题，有几种不同的说法，有的说内存分为五大分区，有的说分为四大分区，我们先来看五大分区的说法：认为内存分为五大分区的人，通常会这样划分：1、BSS段( bss segment )通常是指用来存放程序中未初始化的全局变量和静态变量（这里注意一个问题:一般的书上都会说全局变量和静态变量是会自动初始化的,那么哪来的未初始化的变量呢?变量的初始化可以分为显示初始化和隐式初始化,全局变量和静态变量如果程序员自己不初始化的话的确也会被初始化,那就是不管什么类型都初始化为0,这种没有显示初始化的就是我们这里所说的未初始化。
既然都是0那么就没必要把每个0都存储起来,从而节省磁盘空间,这是BSS的主要作用）的一块内存区域。
BSS是英文Block Started by Symbol的简称。
BSS段属于静态内存分配。
BSS节不包含任何数据,只是简单的维护开始和结束的地址,即总大小。
以便内存区能在运行时分配并被有效地清零。
BSS节在应用程序的二进制映象文件中并不存在,即不占用磁盘空间而只在运行的时候占用内存空间 ,所以如果全局变量和静态变量未初始化那么其可执行文件要小很多。
2、数据段(data segment)通常是指用来存放程序中已经初始化的全局变量和静态变量的一块内存区域。
数据段属于静态内存分配,可以分为只读数据段和读写数据段。
字符串常量等,但一般都是放在只读数据段中。
3、代码段(code segment/text segment)通常是指用来存放程序执行代码的一块内存区域。
static静态变量的理解
static静态变量的理解静态变量类型说明符是static。
静态变量属于静态存储方式，其存储空间为内存中的静态数据区（在静态存储区内分配存储单元），该区域中的数据在整个程序的运行期间一直占用这些存储空间（在程序整个运行期间都不释放），也可以认为是其内存地址不变，直到整个程序运行结束（相反，而auto自动变量，即动态局部变量，属于动态存储类别，占动态存储空间，函数调用结束后即释放）。
静态变量虽在程序的整个执行过程中始终存在，但是在它作用域之外不能使用。
另外，属于静态存储方式的量不一定就是静态变量。
例如：外部变量虽属于静态存储方式，但不一定是静态变量，必须由 static加以定义后才能成为静态外部变量，或称静态全局变量。
所有的全局变量都是静态变量，而局部变量只有定义时加上类型修饰符static，才为局部静态变量。
静态变量可以在任何可以申请的地方申请，一旦申请成功后，它将不再接受其他的同样申请。
静态变量并不是说其就不能改变值，不能改变值的量叫常量。
其拥有的值是可变的，而且它会保持最新的值。
说其静态，是因为它不会随着函数的调用和退出而发生变化。
即上次调用函数的时候，如果我们给静态变量赋予某个值的话，下次函数调用时，这个值保持不变。
一、静态局部变量：1、 Static类内部变量同auto自动变量（即未加 Static 声明的局部变量）一样，是某个特定函数的局部变量，即只能在定义该变量的函数内使用该变量，2者作用域相同；两者的不同在于：auto自动变量会随着函数被调用和退出而存在和消失，而static类局部变量不会，它不管其所在的函数是否被调用，都将一直存在；不过，尽管该变量还继续存在，但不能使用它。
倘若再次调用定义它的函数时，它又可继续使用，而且保存了前次被调用后留下的值。
换言之，Static类型的内部变量是一种只能在某个特定函数中使用，但一直占据存储空间的变量。
2、函数体内如果在定义静态变量的同时进行了初始化，则以后程序不再进行初始化操作（出现在函数内部的基本类型的的静态变量初始化语句只有在第一次调用才执行）。
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在栈上。
内存区划分、内存分配、常量存储区、堆、栈、自由存储区、全局区[C++][内存管理]
![内存区划分、内存分配、常量存储区、堆、栈、自由存储区、全局区[C++][内存管理]](https://img.taocdn.com/s3/m/db4bd2818762caaedd33d4ce.png)
内存区划分、内存分配、常量存储区、堆、栈、自由存储区、全局区[C++][内存管理]一.在c中分为这几个存储区1.栈- 由编译器自动分配释放2.堆- 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收3.全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
- 程序结束释放4.另外还有一个专门放常量的地方。
- 程序结束释放#define不占用内存单元。
C++编译器通常并不给const常量分配存储空间，而是把const变量的定义保存在符号表里。
在VC中，const变量与一般变量一样，都分配内存空间。
在函数体中定义的变量通常是在栈上，用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。
在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区）,在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static 表示只在该函数体内有效。
另外，函数中的"adgfdf"这样的字符串存放在常量区。
比如：int a = 0; //全局初始化区char *p1; //全局未初始化区void main(){int b; //栈char s[] = "abc"; //栈char *p2; //栈char *p3 = "123456"; //123456{post.content}在常量区，p3在栈上static int c = 0; //全局（静态）初始化区p1 = (char *)malloc(10); //分配得来得10字节的区域在堆区p2 = (char *)malloc(20); //分配得来得20字节的区域在堆区strcpy(p1, "123456");//123456{post.content}放在常量区，编译器可能会将它与p3所指向的"123456"优化成一块}二.在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区1.栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。
4399面试笔试题
4399⾯试笔试题3⽉份投了简历去4399，过了两天接到⾯试通知。
⾯试职位同样是C++开发，题⽬都⽐较基础。
我抽取了⼏个我记得的题⽬，⽹上找了答案给⼤家参考⼀下。
1. ⽤预处理指令#define 声明⼀个常数，⽤以表明1年中有多少秒（忽略闰年问题）#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL我在这想看到⼏件事情：1). #define 语法的基本知识（例如：不能以分号结束，括号的使⽤，等等）2). 懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算⼀年中有多少秒⽽不是计算出实际的值，是更清晰⽽没有代价的。
3). 意识到这个表达式将使⼀个16位机的整型数溢出-因此要⽤到长整型符号L,告诉编译器这个常数是的长整型数。
4). 如果你在你的表达式中⽤到UL（表⽰⽆符号长整型），那么你有了⼀个好的起点。
记住，第⼀印象很重要。
2.简述C、C++程序编译的内存分配情况（1）从静态存储区域分配：内存在程序编译时就已经分配好，这块内存在程序的整个运⾏期间都存在。
速度快、不容易出错，因为有系统会善后。
例如全局变量，static变量等。
（2）在栈上分配：在执⾏函数时，函数内局部变量的存储单元都在栈上创建，函数执⾏结束时这些存储单元⾃动被释放。
栈内存分配运算内置于处理器的指令集中，效率很⾼，但是分配的内存容量有限。
（3）从堆上分配：即动态内存分配。
程序在运⾏的时候⽤malloc或new申请任意⼤⼩的内存，程序员⾃⼰负责在何时⽤free或delete释放内存。
动态内存的⽣存期由程序员决定，使⽤⾮常灵活。
如果在堆上分配了空间，就有责任回收它，否则运⾏的程序会出现内存泄漏，另外频繁地分配和释放不同⼤⼩的堆空间将会产⽣堆内碎块。
⼀个C、C++程序编译时内存分为5⼤存储区：堆区、栈区、全局区、⽂字常量区、程序代码区。
3.进程间通信的⽅式有哪些？进程间通信的⽅式有共享内存，管道，Socket ，消息队列 , DDE等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
内存区划分、内存分配、常量存储区、堆、栈、自由存储区、全局区[C++][内存管理]一.在c中分为这几个存储区1.栈- 由编译器自动分配释放2.堆- 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收3.全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
- 程序结束释放4.另外还有一个专门放常量的地方。
- 程序结束释放#define不占用内存单元。
C++编译器通常并不给const常量分配存储空间，而是把const变量的定义保存在符号表里。
在VC中，const变量与一般变量一样，都分配内存空间。
在函数体中定义的变量通常是在栈上，用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。
在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区）,在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static 表示只在该函数体内有效。
另外，函数中的"adgfdf"这样的字符串存放在常量区。
比如：int a = 0; //全局初始化区char *p1; //全局未初始化区void main(){int b; //栈char s[] = "abc"; //栈char *p2; //栈char *p3 = "123456"; //123456{post.content}在常量区，p3在栈上static int c = 0; //全局（静态）初始化区p1 = (char *)malloc(10); //分配得来得10字节的区域在堆区p2 = (char *)malloc(20); //分配得来得20字节的区域在堆区strcpy(p1, "123456");//123456{post.content}放在常量区，编译器可能会将它与p3所指向的"123456"优化成一块}二.在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区1.栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。
里面的变量通常是局部变量、函数参数等。
2.堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
3.自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
4.全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
5.常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改）三. 谈谈堆与栈的关系与区别具体地说，现代计算机(串行执行机制)，都直接在代码底层支持栈的数据结构。
这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。
这种机制的特点是效率高，支持的数据有限，一般是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持其他的数据结构。
因为栈的这种特点，对栈的使用在程序中是非常频繁的。
对子程序的调用就是直接利用栈完成的。
机器的call指令里隐含了把返回地址推入栈，然后跳转至子程序地址的操作，而子程序中的ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。
C/C++中的自动变量是直接利用栈的例子，这也就是为什么当函数返回时，该函数的自动变量自动失效的原因。
和栈不同，堆的数据结构并不是由系统(无论是机器系统还是操作系统)支持的，而是由函数库提供的。
基本的malloc/realloc/free 函数维护了一套内部的堆数据结构。
当程序使用这些函数去获得新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利用系统调用来动态增加程序数据段的内存大小，新分配得到的空间首先被组织进内部堆中去，然后再以适当的形式返回给调用者。
当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会被适当的处理(比如和其他空闲空间合并成更大的空闲空间)，以更适合下一次内存分配申请。
这套复杂的分配机制实际上相当于一个内存分配的缓冲池(Cache)，使用这套机制有如下若干原因：1. 系统调用可能不支持任意大小的内存分配。
有些系统的系统调用只支持固定大小及其倍数的内存请求(按页分配)；这样的话对于大量的小内存分类来说会造成浪费。
2. 系统调用申请内存可能是代价昂贵的。
系统调用可能涉及用户态和核心态的转换。
3. 没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片。
堆和栈的对比从以上知识可知，栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而栈是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。
栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。
不同堆分配的内存无法互相操作。
栈空间分静态分配和动态分配两种。
静态分配是编译器完成的，比如自动变量(auto)的分配。
动态分配由alloca函数完成。
栈的动态分配无需释放(是自动的)，也就没有释放函数。
为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/ 释放内存匹配是良好程序的基本要素。
1.碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。
对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以>参考数据结构，这里我们就不再一一讨论了。
2.生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
3.分配方式：堆都是动态分配的，没有静态分配的堆。
栈有2种分配方式：静态分配和动态分配。
静态分配是编译器完成的，比如局部变量的分配。
动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
4.分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。
堆则是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信息去进行释放内存的工作。
好了，我们回到我们的主题：堆和栈究竟有什么区别？主要的区别由以下几点：1、管理方式不同；2、空间大小不同；3、能否产生碎片不同；4、生长方向不同；5、分配方式不同；6、分配效率不同；管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。
但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。
当然，我们可以修改：打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。
注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。
堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。
所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。
所以，我们推荐大家尽量用栈，而不是用堆。
另外对存取效率的比较:代码:char s1[] = "aaaaaaaaaaaaaaa";char *s2 = "bbbbbbbbbbbbbbbbb";aaaaaaaaaaa是在运行时刻赋值的；而bbbbbbbbbbb是在编译时就确定的；但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
比如：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],cl11: 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读取字符，显然慢了.无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉,编写稳定安全的代码才是最重要的。