堆和栈的区别

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

http://www.uyuan.net/list.asp?unid=13478

 

windows进程中的内存结构

在阅读本文之前，如果你连堆栈是什么多不知道的话，请先阅读文章后面的基础知识。 

接触过编程的人都知道，高级语言都能通过变量名来访问内存中的数据。那么这些变量在内存中是如何存放的呢？程序又是如何使用这些变量的呢？下面就会对此进行深入的讨论。下文中的C语言代码如没有特别声明，默认都使用VC编译的release版。 

首先，来了解一下 C 语言的变量是如何在内存分部的。C 语言有全局变量(Global)、本地变量(Local)，静态变量(Static)、寄存器变量(Regeister)。每种变量都有不同的分配方式。先来看下面这段代码： 

#include <stdio.h> 

int g1=0, g2=0, g3=0; 

int main() 
{ 
static int s1=0, s2=0, s3=0; 
int v1=0, v2=0, v3=0; 

//打印出各个变量的内存地址 

printf("0x%08x/n",&v1); //打印各本地变量的内存地址 
printf("0x%08x/n",&v2); 
printf("0x%08x/n/n",&v3); 
printf("0x%08x/n",&g1); //打印各全局变量的内存地址 
printf("0x%08x/n",&g2); 
printf("0x%08x/n/n",&g3); 
printf("0x%08x/n",&s1); //打印各静态变量的内存地址 
printf("0x%08x/n",&s2); 
printf("0x%08x/n/n",&s3); 
return 0; 
} 

编译后的执行结果是： 

0x0012ff78 
0x0012ff7c 
0x0012ff80 

0x004068d0 
0x004068d4 
0x004068d8 

0x004068dc 
0x004068e0 
0x004068e4 

输出的结果就是变量的内存地址。其中v1,v2,v3是本地变量，g1,g2,g3是全局变量，s1,s2,s3是静态变量。你可以看到这些变量在内存是连续分布的，但是本地变量和全局变量分配的内存地址差了十万八千里，而全局变量和静态变量分配的内存是连续的。这是因为本地变量和全局/静态变量是分配在不同类型的内存区域中的结果。对于一个进程的内存空间而言，可以在逻辑上分成3个部份：代码区，静态数据区和动态数据区。动态数据区一般就是“堆栈”。“栈(stack)”和“堆(heap)”是两种不同的动态数据区，栈是一种线性结构，堆是一种链式结构。进程的每个线程都有私有的“栈”，所以每个线程虽然代码一样，但本地变量的数据都是互不干扰。一个堆栈可以通过“基地址”和“栈顶”地址来描述。全局变量和静态变量分配在静态数据区，本地变量分配在动态数据区，即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。 

├———————┤低端内存区域 
│ …… │ 
├———————┤ 
│ 动态数据区 │ 
├———————┤ 
│ …… │ 
├———————┤ 
│ 代码区 │ 
├———————┤ 
│ 静态数据区 │ 
├———————┤ 
│ …… │ 
├———————┤高端内存区域 

堆栈是一个先进后出的数据结构，栈顶地址总是小于等于栈的基地址。我们可以先了解一下函数调用的过程，以便对堆栈在程序中的作用有更深入的了解。不同的语言有不同的函数调用规定，这些因素有参数的压入规则和堆栈的平衡。windows API的调用规则和ANSI C的函数调用规则是不一样的，前者由被调函数调整堆栈，后者由调用者调整堆栈。两者通过“__stdcall”和“__cdecl”前缀区分。先看下面这段代码： 

#include <stdio.h> 

void __stdcall func(int param1,int param2,int param3) 
{ 
int var1=param1; 
int var2=param2; 
int var3=param3; 
printf("0x%08x/n",¶m1); //打印出各个变量的内存地址 
printf("0x%08x/n",¶m2); 
printf("0x%08x/n/n",¶m3); 
printf("0x%08x/n",&var1); 
printf("0x%08x/n",&var2); 
printf("0x%08x/n/n",&var3); 
return; 
} 

int main() 
{ 
func(1,2,3); 
return 0; 
} 

编译后的执行结果是： 

0x0012ff78 
0x0012ff7c 
0x0012ff80 

0x0012ff68 
0x0012ff6c 
0x0012ff70 

├———————┤<—函数执行时的栈顶（ESP）、低端内存区域 
│ …… │ 
├———————┤ 
│ var 1 │ 
├———————┤ 
│ var 2 │ 
├———————┤ 
│ var 3 │ 
├———————┤ 
│ RET │ 
├———————┤<—“__cdecl”函数返回后的栈顶（ESP） 
│ parameter 1 │ 
├———————┤ 
│ parameter 2 │ 
├———————┤ 
│ parameter 3 │ 
├———————┤<—“__stdcall”函数返回后的栈顶（ESP） 
│ …… │ 
├———————┤<—栈底（基地址 EBP）、高端内存区域 

上图就是函数调用过程中堆栈的样子了。首先，三个参数以从又到左的次序压入堆栈，先压“param3”，再压“param2”，最后压入“param1”；然后压入函数的返回地址(RET)，接着跳转到函数地址接着执行（这里要补充一点，介绍UNIX下的缓冲溢出原理的文章中都提到在压入RET后，继续压入当前EBP，然后用当前ESP代替EBP。然而，有一篇介绍windows下函数调用的文章中说，在windows下的函数调用也有这一步骤，但根据我的实际调试，并未发现这一步，这还可以从param3和var1之间只有4字节的间隙这点看出来）；第三步，将栈顶(ESP)减去一个数，为本地变量分配内存空间，上例中是减去12字节(ESP=ESP-3*4，每个int变量占用4个字节)；接着就初始化本地变量的内存空间。由于“__stdcall”调用由被调函数调整堆栈，所以在函数返回前要恢复堆栈，先回收本地变量占用的内存(ESP=ESP+3*4)，然后取出返回地址，填入EIP寄存器，回收先前压入参数占用的内存(ESP=ESP+3*4)，继续执行调用者的代码。参见下列汇编代码： 

;--------------func 函数的汇编代码------------------- 

:00401000 83EC0C sub esp, 0000000C //创建本地变量的内存空间 
:00401003 8B442410 mov eax, dword ptr [esp+10] 
:00401007 8B4C2414 mov ecx, dword ptr [esp+14] 
:0040100B 8B542418 mov edx, dword ptr [esp+18] 
:0040100F 89442400 mov dword ptr [esp], eax 
:00401013 8D442410 lea eax, dword ptr [esp+10] 
:00401017 894C2404 mov dword ptr [esp+04], ecx 

……………………（省略若干代码） 

:00401075 83C43C add esp, 0000003C ;恢复堆栈，回收本地变量的内存空间 
:00401078 C3 ret 000C ;函数返回，恢复参数占用的内存空间 
;如果是“__cdecl”的话，这里是“ret”，堆栈将由调用者恢复 

;-------------------函数结束------------------------- 

;--------------主程序调用func函数的代码-------------- 

:00401080 6A03 push 00000003 //压入参数param3 
:00401082 6A02 push 00000002 //压入参数param2 
:00401084 6A01 push 00000001 //压入参数param1 
:00401086 E875FFFFFF call 00401000 //调用func函数 
;如果是“__cdecl”的话，将在这里恢复堆栈，“add esp, 0000000C” 

聪明的读者看到这里，差不多就明白缓冲溢出的原理了。先来看下面的代码： 

#include <stdio.h> 
#include <string.h> 

void __stdcall func() 
{ 
char lpBuff[8]="/0"; 
strcat(lpBuff,"AAAAAAAAAAA"); 
return; 
} 

int main() 
{ 
func(); 
return 0; 
} 

编译后执行一下回怎么样？哈，“"0x00414141"指令引用的"0x00000000"内存。该内存不能为"read"。”，“非法操作”喽！"41"就是"A"的16进制的ASCII码了，那明显就是strcat这句出的问题了。"lpBuff"的大小只有8字节，算进结尾的/0，那strcat最多只能写入7个"A"，但程序实际写入了11个"A"外加1个/0。再来看看上面那幅图，多出来的4个字节正好覆盖了RET的所在的内存空间，导致函数返回到一个错误的内存地址，执行了错误的指令。如果能精心构造这个字符串，使它分成三部分，前一部份仅仅是填充的无意义数据以达到溢出的目的，接着是一个覆盖RET的数据，紧接着是一段shellcode，那只要着个RET地址能指向这段shellcode的第一个指令，那函数返回时就能执行shellcode了。但是软件的不同版本和不同的运行环境都可能影响这段shellcode在内存中的位置，那么要构造这个RET是十分困难的。一般都在RET和shellcode之间填充大量的NOP指令，使得exploit有更强的通用性。 

├———————┤<—低端内存区域 
│ …… │ 
├———————┤<—由exploit填入数据的开始 
│ │ 
│ buffer │<—填入无用的数据 
│ │ 
├———————┤ 
│ RET │<—指向shellcode，或NOP指令的范围 
├———————┤ 
│ NOP │ 
│ …… │<—填入的NOP指令，是RET可指向的范围 
│ NOP │ 
├———————┤ 
│ │ 
│ shellcode │ 
│ │ 
├———————┤<—由exploit填入数据的结束 
│ …… │ 
├———————┤<—高端内存区域 

windows下的动态数据除了可存放在栈中，还可以存放在堆中。了解C++的朋友都知道，C++可以使用new关键字来动态分配内存。来看下面的C++代码： 

#include <stdio.h> 
#include <iostream.h> 
#include <windows.h> 

void func() 
{ 
char *buffer=new char[128]; 
char bufflocal[128]; 
static char buffstatic[128]; 
printf("0x%08x/n",buffer); //打印堆中变量的内存地址 
printf("0x%08x/n",bufflocal); //打印本地变量的内存地址 
printf("0x%08x/n",buffstatic); //打印静态变量的内存地址 
} 

void main() 
{ 
func(); 
return; 
} 

程序执行结果为： 

0x004107d0 
0x0012ff04 
0x004068c0 

可以发现用new关键字分配的内存即不在栈中，也不在静态数据区。VC编译器是通过windows下的“堆(heap)”来实现new关键字的内存动态分配。在讲“堆”之前，先来了解一下和“堆”有关的几个API函数： 

HeapAlloc 在堆中申请内存空间 
HeapCreate 创建一个新的堆对象 
HeapDestroy 销毁一个堆对象 
HeapFree 释放申请的内存 
HeapWalk 枚举堆对象的所有内存块 
GetProcessHeap 取得进程的默认堆对象 
GetProcessHeaps 取得进程所有的堆对象 
LocalAlloc 
GlobalAlloc 

当进程初始化时，系统会自动为进程创建一个默认堆，这个堆默认所占内存的大小为1M。堆对象由系统进行管理，它在内存中以链式结构存在。通过下面的代码可以通过堆动态申请内存空间： 

HANDLE hHeap=GetProcessHeap(); 
char *buff=HeapAlloc(hHeap,0,8); 

其中hHeap是堆对象的句柄，buff是指向申请的内存空间的地址。那这个hHeap究竟是什么呢？它的值有什么意义吗？看看下面这段代码吧： 

#pragma comment(linker,"/entry:main") //定义程序的入口 
#include <windows.h> 

_CRTIMP int (__cdecl *printf)(const char *, ...); //定义STL函数printf 
/*--------------------------------------------------------------------------- 
写到这里，我们顺便来复习一下前面所讲的知识： 
(*注)printf函数是C语言的标准函数库中函数，VC的标准函数库由msvcrt.dll模块实现。 
由函数定义可见，printf的参数个数是可变的，函数内部无法预先知道调用者压入的参数个数，函数只能通过分析第一个参数字符串的格式来获得压入参数的信息，由于这里参数的个数是动态的，所以必须由调用者来平衡堆栈，这里便使用了__cdecl调用规则。BTW，Windows系统的API函数基本上是__stdcall调用形式，只有一个API例外，那就是wsprintf，它使用__cdecl调用规则，同printf函数一样，这是由于它的参数个数是可变的缘故。 
---------------------------------------------------------------------------*/ 
void main() 
{ 
HANDLE hHeap=GetProcessHeap(); 
char *buff=HeapAlloc(hHeap,0,0x10); 
char *buff2=HeapAlloc(hHeap,0,0x10); 
HMODULE hMsvcrt=LoadLibrary("msvcrt.dll"); 
printf=(void *)GetProcAddress(hMsvcrt,"printf"); 
printf("0x%08x/n",hHeap); 
printf("0x%08x/n",buff); 
printf("0x%08x/n/n",buff2); 
} 

执行结果为： 

0x00130000 
0x00133100 
0x00133118 

hHeap的值怎么和那个buff的值那么接近呢？其实hHeap这个句柄就是指向HEAP首部的地址。在进程的用户区存着一个叫PEB(进程环境块)的结构，这个结构中存放着一些有关进程的重要信息，其中在PEB首地址偏移0x18处存放的ProcessHeap就是进程默认堆的地址，而偏移0x90处存放了指向进程所有堆的地址列表的指针。windows有很多API都使用进程的默认堆来存放动态数据，如windows 2000下的所有ANSI版本的函数都是在默认堆中申请内存来转换ANSI字符串到Unicode字符串的。对一个堆的访问是顺序进行的，同一时刻只能有一个线程访问堆中的数据，当多个线程同时有访问要求时，只能排队等待，这样便造成程序执行效率下降。 

最后来说说内存中的数据对齐。所位数据对齐，是指数据所在的内存地址必须是该数据长度的整数倍，DWORD数据的内存起始地址能被4除尽，WORD数据的内存起始地址能被2除尽，x86 CPU能直接访问对齐的数据，当他试图访问一个未对齐的数据时，会在内部进行一系列的调整，这些调整对于程序来说是透明的，但是会降低运行速度，所以编译器在编译程序时会尽量保证数据对齐。同样一段代码，我们来看看用VC、Dev-C++和lcc三个不同编译器编译出来的程序的执行结果： 

#include <stdio.h> 

int main() 
{ 
int a; 
char b; 
int c; 
printf("0x%08x/n",&a); 
printf("0x%08x/n",&b); 
printf("0x%08x/n",&c); 
return 0; 
} 

这是用VC编译后的执行结果： 
0x0012ff7c 
0x0012ff7b 
0x0012ff80 
变量在内存中的顺序：b(1字节)-a(4字节)-c(4字节)。 

这是用Dev-C++编译后的执行结果： 
0x0022ff7c 
0x0022ff7b 
0x0022ff74 
变量在内存中的顺序：c(4字节)-中间相隔3字节-b(占1字节)-a(4字节)。 

这是用lcc编译后的执行结果： 
0x0012ff6c 
0x0012ff6b 
0x0012ff64 
变量在内存中的顺序：同上。 

三个编译器都做到了数据对齐，但是后两个编译器显然没VC“聪明”，让一个char占了4字节，浪费内存哦。 

基础知识： 
堆栈是一种简单的数据结构，是一种只允许在其一端进行插入或删除的线性表。允许插入或删除操作的一端称为栈顶，另一端称为栈底，对堆栈的插入和删除操作被称为入栈和出栈。有一组CPU指令可以实现对进程的内存实现堆栈访问。其中，POP指令实现出栈操作，PUSH指令实现入栈操作。CPU的ESP寄存器存放当前线程的栈顶指针，EBP寄存器中保存当前线程的栈底指针。CPU的EIP寄存器存放下一个CPU指令存放的内存地址，当CPU执行完当前的指令后，从EIP寄存器中读取下一条指令的内存地址，然后继续执行。 

参考：《Windows下的HEAP溢出及其利用》by: isno 
《windows核心编程》by: Jeffrey Richter 

www.uyuan.net文章来源于U缘网络
堆：欢乐和痛苦
Murali R. Krishnan
Microsoft Corporation

 

1999 年 2 月

摘要： 讨论常见的堆性能问题以及如何防范它们。（共 9 页）

前言
您是否是动态分配的 C/C++ 对象忠实且幸运的用户？您是否在模块间的往返通信中频繁地使用了“自动化”？您的程序是否因堆分配而运行起来很慢？不仅仅您遇到这样的问题。几乎所有项目迟早都会遇到堆问题。大家都想说，“我的代码真正好，只是堆太慢”。那只是部分正确。更深入理解堆及其用法、以及会发生什么问题，是很有用的。

什么是堆？
（如果您已经知道什么是堆，可以跳到“什么是常见的堆性能问题？”部分）

在程序中，使用堆来动态分配和释放对象。在下列情况下，调用堆操作： 

事先不知道程序所需对象的数量和大小。

对象太大而不适合堆栈分配程序。
堆使用了在运行时分配给代码和堆栈的内存之外的部分内存。下图给出了堆分配程序的不同层。

此主题相关图片如下：

GlobalAlloc/GlobalFree：Microsoft Win32 堆调用，这些调用直接与每个进程的默认堆进行对话。

LocalAlloc/LocalFree：Win32 堆调用（为了与 Microsoft Windows NT 兼容），这些调用直接与每个进程的默认堆进行对话。

COM 的 IMalloc 分配程序（或 CoTaskMemAlloc / CoTaskMemFree）：函数使用每个进程的默认堆。自动化程序使用“组件对象模型 (COM)”的分配程序，而申请的程序使用每个进程堆。

C/C++ 运行时 (CRT) 分配程序：提供了 malloc() 和 free() 以及 new 和 delete 操作符。如 Microsoft Visual Basic 和 Java 等语言也提供了新的操作符并使用垃圾收集来代替堆。CRT 创建自己的私有堆，驻留在 Win32 堆的顶部。

Windows NT 中，Win32 堆是 Windows NT 运行时分配程序周围的薄层。所有 API 转发它们的请求给 NTDLL。

Windows NT 运行时分配程序提供 Windows NT 内的核心堆分配程序。它由具有 128 个大小从 8 到 1,024 字节的空闲列表的前端分配程序组成。后端分配程序使用虚拟内存来保留和提交页。

在图表的底部是“虚拟内存分配程序”，操作系统使用它来保留和提交页。所有分配程序使用虚拟内存进行数据的存取。

分配和释放块不就那么简单吗？为何花费这么长时间？

堆实现的注意事项
传统上，操作系统和运行时库是与堆的实现共存的。在一个进程的开始，操作系统创建一个默认堆，叫做“进程堆”。如果没有其他堆可使用，则块的分配使用“进程堆”。语言运行时也能在进程内创建单独的堆。（例如，C 运行时创建它自己的堆。）除这些专用的堆外，应用程序或许多已载入的动态链接库 (DLL) 之一可以创建和使用单独的堆。Win32 提供一整套 API 来创建和使用私有堆。有关堆函数（英文）的详尽指导，请参见 MSDN。

当应用程序或 DLL 创建私有堆时，这些堆存在于进程空间，并且在进程内是可访问的。从给定堆分配的数据将在同一个堆上释放。（不能从一个堆分配而在另一个堆释放。）

在所有虚拟内存系统中，堆驻留在操作系统的“虚拟内存管理器”的顶部。语言运行时堆也驻留在虚拟内存顶部。某些情况下，这些堆是操作系统堆中的层，而语言运行时堆则通过大块的分配来执行自己的内存管理。不使用操作系统堆，而使用虚拟内存函数更利于堆的分配和块的使用。

典型的堆实现由前、后端分配程序组成。前端分配程序维持固定大小块的空闲列表。对于一次分配调用，堆尝试从前端列表找到一个自由块。如果失败，堆被迫从后端（保留和提交虚拟内存）分配一个大块来满足请求。通用的实现有每块分配的开销，这将耗费执行周期，也减少了可使用的存储空间。

Knowledge Base 文章 Q10758，“用 calloc() 和 malloc() 管理内存” （搜索文章编号）, 包含了有关这些主题的更多背景知识。另外，有关堆实现和设计的详细讨论也可在下列著作中找到：“Dynamic Storage Allocation: A Survey and Critical Review”，作者 Paul R. Wilson、Mark S. Johnstone、Michael Neely 和 David Boles；“International Workshop on Memory Management”, 作者 Kinross, Scotland, UK, 1995 年 9 月(http://www.cs.utexas.edu/users/oops/papers.html)（英文）。

Windows NT 的实现（Windows NT 版本 4.0 和更新版本） 使用了 127 个大小从 8 到 1,024 字节的 8 字节对齐块空闲列表和一个“大块”列表。“大块”列表（空闲列表[0]） 保存大于 1,024 字节的块。空闲列表容纳了用双向链表链接在一起的对象。默认情况下，“进程堆”执行收集操作。（收集是将相邻空闲块合并成一个大块的操作。）收集耗费了额外的周期，但减少了堆块的内部碎片。

单一全局锁保护堆，防止多线程式的使用。（请参见“Server Performance and Scalability Killers”中的第一个注意事项, George Reilly 所著，在 “MSDN Online Web Workshop”上（站点：http://msdn.microsoft.com/workshop/server/iis/tencom.asp（英文）。）单一全局锁本质上是用来保护堆数据结构，防止跨多线程的随机存取。若堆操作太频繁，单一全局锁会对性能有不利的影响。

什么是常见的堆性能问题？
以下是您使用堆时会遇到的最常见问题： 

分配操作造成的速度减慢。光分配就耗费很长时间。最可能导致运行速度减慢原因是空闲列表没有块，所以运行时分配程序代码会耗费周期寻找较大的空闲块，或从后端分配程序分配新块。

释放操作造成的速度减慢。释放操作耗费较多周期，主要是启用了收集操作。收集期间，每个释放操作“查找”它的相邻块，取出它们并构造成较大块，然后再把此较大块插入空闲列表。在查找期间，内存可能会随机碰到，从而导致高速缓存不能命中，性能降低。

堆竞争造成的速度减慢。当两个或多个线程同时访问数据，而且一个线程继续进行之前必须等待另一个线程完成时就发生竞争。竞争总是导致麻烦；这也是目前多处理器系统遇到的最大问题。当大量使用内存块的应用程序或 DLL 以多线程方式运行（或运行于多处理器系统上）时将导致速度减慢。单一锁定的使用—常用的解决方案—意味着使用堆的所有操作是序列化的。当等待锁定时序列化会引起线程切换上下文。可以想象交叉路口闪烁的红灯处走走停停导致的速度减慢。 
竞争通常会导致线程和进程的上下文切换。上下文切换的开销是很大的，但开销更大的是数据从处理器高速缓存中丢失，以及后来线程复活时的数据重建。

堆破坏造成的速度减慢。造成堆破坏的原因是应用程序对堆块的不正确使用。通常情形包括释放已释放的堆块或使用已释放的堆块，以及块的越界重写等明显问题。（破坏不在本文讨论范围之内。有关内存重写和泄漏等其他细节，请参见 Microsoft Visual C++(R) 调试文档 。）

频繁的分配和重分配造成的速度减慢。这是使用脚本语言时非常普遍的现象。如字符串被反复分配，随重分配增长和释放。不要这样做，如果可能，尽量分配大字符串和使用缓冲区。另一种方法就是尽量少用连接操作。
竞争是在分配和释放操作中导致速度减慢的问题。理想情况下，希望使用没有竞争和快速分配/释放的堆。可惜，现在还没有这样的通用堆，也许将来会有。

在所有的服务器系统中（如 IIS、MSProxy、DatabaseStacks、网络服务器、 Exchange 和其他）, 堆锁定实在是个大瓶颈。处理器数越多，竞争就越会恶化。

尽量减少堆的使用
现在您明白使用堆时存在的问题了，难道您不想拥有能解决这些问题的超级魔棒吗？我可希望有。但没有魔法能使堆运行加快—因此不要期望在产品出货之前的最后一星期能够大为改观。如果提前规划堆策略，情况将会大大好转。调整使用堆的方法，减少对堆的操作是提高性能的良方。

如何减少使用堆操作？通过利用数据结构内的位置可减少堆操作的次数。请考虑下列实例：

struct ObjectA {
   // objectA 的数据 
}

struct ObjectB {
   // objectB 的数据 
}

// 同时使用 objectA 和 objectB

//
// 使用指针 
//
struct ObjectB {
   struct ObjectA * pObjA;
   // objectB 的数据 
}

//
// 使用嵌入
//
struct ObjectB {
   struct ObjectA pObjA;
   // objectB 的数据 
}

//
// 集合 – 在另一对象内使用 objectA 和 objectB
//

struct ObjectX {
   struct ObjectA  objA;
   struct ObjectB  objB;
}

避免使用指针关联两个数据结构。如果使用指针关联两个数据结构，前面实例中的对象 A 和 B 将被分别分配和释放。这会增加额外开销—我们要避免这种做法。

把带指针的子对象嵌入父对象。当对象中有指针时，则意味着对象中有动态元素（百分之八十）和没有引用的新位置。嵌入增加了位置从而减少了进一步分配/释放的需求。这将提高应用程序的性能。

合并小对象形成大对象（聚合）。聚合减少分配和释放的块的数量。如果有几个开发者，各自开发设计的不同部分，则最终会有许多小对象需要合并。集成的挑战就是要找到正确的聚合边界。

内联缓冲区能够满足百分之八十的需要（aka 80-20 规则）。个别情况下，需要内存缓冲区来保存字符串/二进制数据，但事先不知道总字节数。估计并内联一个大小能满足百分之八十需要的缓冲区。对剩余的百分之二十，可以分配一个新的缓冲区和指向这个缓冲区的指针。这样，就减少分配和释放调用并增加数据的位置空间，从根本上提高代码的性能。

在块中分配对象（块化）。块化是以组的方式一次分配多个对象的方法。如果对列表的项连续跟踪，例如对一个 {名称，值} 对的列表，有两种选择：选择一是为每一个“名称-值”对分配一个节点；选择二是分配一个能容纳（如五个）“名称-值”对的结构。例如，一般情况下，如果存储四对，就可减少节点的数量，如果需要额外的空间数量，则使用附加的链表指针。 
块化是友好的处理器高速缓存，特别是对于 L1-高速缓存，因为它提供了增加的位置 —不用说对于块分配，很多数据块会在同一个虚拟页中。

正确使用 _amblksiz。C 运行时 (CRT) 有它的自定义前端分配程序，该分配程序从后端（Win32 堆）分配大小为 _amblksiz 的块。将 _amblksiz 设置为较高的值能潜在地减少对后端的调用次数。这只对广泛使用 CRT 的程序适用。
使用上述技术将获得的好处会因对象类型、大小及工作量而有所不同。但总能在性能和可升缩性方面有所收获。另一方面，代码会有点特殊，但如果经过深思熟虑，代码还是很容易管理的。

其他提高性能的技术
下面是一些提高速度的技术： 

使用 Windows NT5 堆 
由于几个同事的努力和辛勤工作，1998 年初 Microsoft Windows(R) 2000 中有了几个重大改进：

改进了堆代码内的锁定。堆代码对每堆一个锁。全局锁保护堆数据结构，防止多线程式的使用。但不幸的是，在高通信量的情况下，堆仍受困于全局锁，导致高竞争和低性能。Windows 2000 中，锁内代码的临界区将竞争的可能性减到最小,从而提高了可伸缩性。

使用 “Lookaside”列表。堆数据结构对块的所有空闲项使用了大小在 8 到 1,024 字节（以 8-字节递增）的快速高速缓存。快速高速缓存最初保护在全局锁内。现在，使用 lookaside 列表来访问这些快速高速缓存空闲列表。这些列表不要求锁定，而是使用 64 位的互锁操作，因此提高了性能。

内部数据结构算法也得到改进。
这些改进避免了对分配高速缓存的需求，但不排除其他的优化。使用 Windows NT5 堆评估您的代码；它对小于 1,024 字节 (1 KB) 的块（来自前端分配程序的块）是最佳的。GlobalAlloc() 和 LocalAlloc() 建立在同一堆上，是存取每个进程堆的通用机制。如果希望获得高的局部性能，则使用 Heap(R) API 来存取每个进程堆，或为分配操作创建自己的堆。如果需要对大块操作，也可以直接使用 VirtualAlloc() / VirtualFree() 操作。

上述改进已在 Windows 2000 beta 2 和 Windows NT 4.0 SP4 中使用。改进后，堆锁的竞争率显著降低。这使所有 Win32 堆的直接用户受益。CRT 堆建立于 Win32 堆的顶部，但它使用自己的小块堆，因而不能从 Windows NT 改进中受益。（Visual C++ 版本 6.0 也有改进的堆分配程序。）

使用分配高速缓存 
分配高速缓存允许高速缓存分配的块，以便将来重用。这能够减少对进程堆（或全局堆）的分配/释放调用的次数，也允许最大限度的重用曾经分配的块。另外，分配高速缓存允许收集统计信息,以便较好地理解对象在较高层次上的使用。

典型地，自定义堆分配程序在进程堆的顶部实现。自定义堆分配程序与系统堆的行为很相似。主要的差别是它在进程堆的顶部为分配的对象提供高速缓存。高速缓存设计成一套固定大小（如 32 字节、64 字节、128 字节等）。这一个很好的策略，但这种自定义堆分配程序丢失与分配和释放的对象相关的“语义信息”。 

与自定义堆分配程序相反，“分配高速缓存”作为每类分配高速缓存来实现。除能够提供自定义堆分配程序的所有好处之外，它们还能够保留大量语义信息。每个分配高速缓存处理程序与一个目标二进制对象关联。它能够使用一套参数进行初始化，这些参数表示并发级别、对象大小和保持在空闲列表中的元素的数量等。分配高速缓存处理程序对象维持自己的私有空闲实体池（不超过指定的阀值）并使用私有保护锁。合在一起，分配高速缓存和私有锁减少了与主系统堆的通信量，因而提供了增加的并发、最大限度的重用和较高的可伸缩性。

需要使用清理程序来定期检查所有分配高速缓存处理程序的活动情况并回收未用的资源。如果发现没有活动，将释放分配对象的池，从而提高性能。

可以审核每个分配/释放活动。第一级信息包括对象、分配和释放调用的总数。通过查看它们的统计信息可以得出各个对象之间的语义关系。利用以上介绍的许多技术之一，这种关系可以用来减少内存分配。

分配高速缓存也起到了调试助手的作用，帮助您跟踪没有完全清除的对象数量。通过查看动态堆栈返回踪迹和除没有清除的对象之外的签名，甚至能够找到确切的失败的调用者。

MP 堆 
MP 堆是对多处理器友好的分布式分配的程序包，在 Win32 SDK（Windows NT 4.0 和更新版本）中可以得到。最初由 JVert 实现，此处堆抽象建立在 Win32 堆程序包的顶部。MP 堆创建多个 Win32 堆，并试图将分配调用分布到不同堆，以减少在所有单一锁上的竞争。

本程序包是好的步骤 —一种改进的 MP-友好的自定义堆分配程序。但是，它不提供语义信息和缺乏统计功能。通常将 MP 堆作为 SDK 库来使用。如果使用这个 SDK 创建可重用组件，您将大大受益。但是，如果在每个 DLL 中建立这个 SDK 库，将增加工作设置。

重新思考算法和数据结构 
要在多处理器机器上伸缩，则算法、实现、数据结构和硬件必须动态伸缩。请看最经常分配和释放的数据结构。试问，“我能用不同的数据结构完成此工作吗？”例如，如果在应用程序初始化时加载了只读项的列表，这个列表不必是线性链接的列表。如果是动态分配的数组就非常好。动态分配的数组将减少内存中的堆块和碎片，从而增强性能。

减少需要的小对象的数量减少堆分配程序的负载。例如，我们在服务器的关键处理路径上使用五个不同的对象，每个对象单独分配和释放。一起高速缓存这些对象，把堆调用从五个减少到一个，显著减少了堆的负载，特别当每秒钟处理 1,000 个以上的请求时。

如果大量使用“Automation”结构，请考虑从主线代码中删除“Automation BSTR”，或至少避免重复的 BSTR 操作。（BSTR 连接导致过多的重分配和分配/释放操作。）

摘要
对所有平台往往都存在堆实现，因此有巨大的开销。每个单独代码都有特定的要求，但设计能采用本文讨论的基本理论来减少堆之间的相互作用。 

评价您的代码中堆的使用。

改进您的代码，以使用较少的堆调用：分析关键路径和固定数据结构。

在实现自定义的包装程序之前使用量化堆调用成本的方法。

如果对性能不满意，请要求 OS 组改进堆。更多这类请求意味着对改进堆的更多关注。

要求 C 运行时组针对 OS 所提供的堆制作小巧的分配包装程序。随着 OS 堆的改进，C 运行时堆调用的成本将减小。

操作系统（Windows NT 家族）正在不断改进堆。请随时关注和利用这些改进。
Murali Krishnan 是 Internet Information Server (IIS) 组的首席软件设计工程师。从 1.0 版本开始他就设计 IIS，并成功发行了 1.0 版本到 4.0 版本。Murali 组织并领导 IIS 性能组三年 (1995-1998), 从一开始就影响 IIS 性能。他拥有威斯康星州 Madison 大学的 M.S.和印度 Anna 大学的 B.S.。工作之外，他喜欢阅读、打排球和家庭烹饪。

http://community.csdn.net/Expert/FAQ/FAQ_Index.asp?id=172835
我在学习对象的生存方式的时候见到一种是在堆栈(stack)之中，如下  
CObject  object;  
还有一种是在堆(heap)中  如下  
CObject*  pobject=new  CObject();  
 
请问  
（1）这两种方式有什么区别？  
（2）堆栈与堆有什么区别？？  
 
 
---------------------------------------------------------------  
 
1)  about  stack,  system  will  allocate  memory  to  the  instance  of  object  automatically,  and  to  the  heap,

  you  must  allocate  memory  to  the  instance  of  object  with  new  or  malloc  manually.  
2)  when  function  ends,  system  will  automatically  free  the  memory  area  of  stack,  but  to  the  heap,  

you  must  free  the  memory  area  manually  with  free  or  delete,  else  it  will  result  in  memory  leak.  
3)栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。  
4）堆上分配的内存可以有我们自己决定，使用非常灵活。  
---------------------------------------------------------------  
 
 
堆和栈的比较  
 
     从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的，栈主要是用来执行程序的.而这种不同又主要是由于堆和栈的特点决定的:  
 
     在编程中，例如C/C++中，所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶向上用就行,就好像工厂中的传送带(conveyor  belt)一样,Stack  Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候，修改栈指针就可以把栈中的内容销毁.这样的模式速度最快,当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程序运行时进行的,但是分配的大小多少是确定的,不变的,而这个"大小多少"是在编译时确定的,不是在运行时.  
 
     堆是应用程序在运行的时候请求操作系统分配给自己内存，由于从操作系统管理的内存分配,所以在分配和销毁时都要占用时间，因此用堆的效率非常低.但是堆的优点在于,编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间,因此,用堆保存数据时会得到更大的灵活性。事实上,面向对象的多态性,堆内存分配是必不可少的,因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定.在C++中，要求创建一个对象时，只需用new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存.当然，为达到这种灵活性，必然会付出一定的代价:在堆里分配存储空间时会花掉更长的时间！这也正是导致效率低的原因,  
 
我想你现在该明白了吧。：）  
 
---------------------------------------------------------------  
 
学过汇编么？  
内存中的东西分三类：代码(code)、数据(data)、栈(stack),  
其中stack是负责子程序的调用和返回的，stack实行后进先出的机制，调用子程序时先将当前地址的下一个地址临时保存到stack中，而子程序根据这个地址返回。  
在子程序（函数）内部分配的局部变量也是在stack中分配，这样，函数返回时，分配的空间也自动收回。  
而heap则是系统从data区中特别挪用并且独立管理的一个数据区，用于程序执行中数据的动态分配。  
从表相看：全局静态数据在data中，局部分配的静态数据在stack中，动态分配的数据在heap中。 

C++中堆内存(heap)的概念和操作方法

 

堆内存是什么呢？ 

　　我们知道在c/c++中定义的数组大小必需要事先定义好，他们通常是分配在静态内存空间或者是在栈内存空间内的，但是在实际工作中，我们有时候却需要动态的为数组分配大小，在这里c库中的malloc.h头文件中的malloc()函数就为您解决了问题（bc或者是在老的标准中是alloc.h），它的函数原形是void* malloc(size_t size)，在动态开辟的内存中，在使用完后我们要使用free()函数来释放动态开辟的内存空间。

　　下面我们来看一个完整的例子：

#include <iostream>  
#include <malloc.h>  
  
using namespace std;  
main()  
{  
    int arraysize; //元素个数  
    int *array; //用于动态开辟数组的指针变量  
  
    cin>>arraysize;  
    array=(int*)malloc(arraysize * sizeof(int));//利用malloc在堆内存中开辟内存空间,它的大小是元素的个数乘以该数据类型的长度  
  
    for(int i=0;i<arraysize;i++)   
    {  
        array[i]=i;  
    }  
  
    for(int i=0;i<arraysize;i++)  
    {  
        cout<<array[i]<<",";  
    }  
    cout<<endl;  
    free(array);//利用free释放动态开辟的堆内存空间  
    cin.get();  
    cin.get();  
}
　　这里要特别注意个地方就是：

array=(int*)malloc(arraysize * sizeof(int));
　　malloc()的函数原形本身是void* malloc(size_t size)，由于动态分配的空间计算机并不知道是用来做什么的所以是无类型的，但你要把它用在动态的整形数组上的时候就要显式的转换成int*了。

　　下面我们再介绍c++所独有的开辟和释放堆内存空间的方法，new修饰符和delete修饰符。

　　new和delete修饰符的操作并不需要头文件的支持，这是c++所独有的,new操作要比malloc更为简单，直接说明开辟的类型的数目就可以了，delete使用的时候如果是数组那么必须使用delete[]。

#include <iostream>  
  
using namespace std;  
main()  
{  
    int arraysize; //元素个数  
    int *array;  
  
    cin>>arraysize;  
      
    array=new int[arraysize];//开辟堆内存  
  
    for(int i=0;i<arraysize;i++)   
    {  
        array[i]=i;  
    }  
  
    for(int i=0;i<arraysize;i++)  
    {  
        cout<<array[i]<<",";  
    }  
    cout<<endl;  
    delete[] array;//释放堆内存  
    cin.get();  
    cin.get();

 
http://www.zdnet.com.cn/developer/code/story/0,3800066897,39149800,00.htm
了解三种C++存储方式  
作者： ZDNet China 
2003-07-14 12:27 PM 
C++有三种存储方式：自动存储方式，静态存储方式和自由存储方式。每一种存储方式都有不同的对象初始化的方法和生存空间。在下面的段落中我们将阐述这三种存储方式的不同之处，并向大家展示怎样有效而安全地使用它们。

 

自动存储方式
 
 
通常，我们并不把局部对象定义为静态的或者外部的，而是将它定义为自动的和寄存器的。函数的自变量都是自动存储，这种存储方式被称作栈存储。下面的例子包括了多种声明对象的方式、自动存储方式的各种形式。

//s' storage type s is determined by the caller
void f(const std::string & s);

//arguments passed by value are automatic
void g(register int n);

int main()
{
 int n; // automatic because local, non-static, non-extern
 register inti;  // register implies automatic
 auto double d;  // auto implies automatic
 g(n); //passing a copy of n; the copy is automatic
 std::string s;
 f(std::string temp()); // a temp object is also automatic
} 

自动对象通常被建立在一个函数或者一个块中，当函数或块结束时，自动对象就被立即销毁。因而，当它每次进入一个函数或块的时候，自动对象将会创建一个全新的设置，自动变量和无类对象的缺省值是不定的。
 静态存储方式 

静态存储方式
 
 
全局对象、一个类的静态数据成员和函数的静态变量都属于静态存储的范畴。一个静态对象的内存地址在整个程序运行的过程中是不变的。在一个程序的生存空间内，每个静态对象仅被构造一次。

静态数据的缺省值被初始化为二进制零，静态对象随着非无效构造函数（构造函数由编译器或者C++执行）紧接着被初始化。下面的例子展示了怎样静态存储对象。

int num; //global variables have static storage
static int sum; //so do static objects declared globally
intfunc()
{
  static int calls; //initialized to 0 by default
  return ++calls;
}

class C
{
private:
  static bool b;
};

namespace NS
{
  std::stringstr; //str has static storage
} 
 
自由存储方式 

自由存储方式
 
 
自由存储，也被称为堆存储（在C里）或者动态存储，它包括在程序代码中使new来产生所需要的对象和变量。对象和变量将不断的分配存储空间，直到调用删除操作将它们释放。

调用删除程序失败将会引起内存不足，调用构析函数失败的结果则是无法预料的，与自动和静态的对象相比，自由存储对象的地址在运行的时候已经被确定。下面的例子展示了自动存储对象的过程。

int *p = new in  t;
char *s = new char[1024];
Shape *ps=new Triangle;
//s' storage type s is determined by the caller
void f(const std::string & s);
std::string *pstr=new std::string
f(pstr);
delete p;
delete[] s; //s is an array
delete  ps; //invokes the destructor
delete pstr; //ditto 

控制C++的内存分配  
作者： 翻译：javaresearch.org-Abel_Cao 
2003-06-18 01:21 PM 
在嵌入式系统中使用C++的一个常见问题是内存分配，即对new 和 delete 操作符的失控。

 

具有讽刺意味的是，问题的根源却是C++对内存的管理非常的容易而且安全。具体地说，当一个对象被消除时，它的析构函数能够安全的释放所分配的内存。  
 

这当然是个好事情，但是这种使用的简单性使得程序员们过度使用new 和 delete，而不注意在嵌入式C++环境中的因果关系。并且，在嵌入式系统中，由于内存的限制，频繁的动态分配不定大小的内存会引起很大的问题以及堆破碎的风险。

作为忠告，保守的使用内存分配是嵌入式环境中的第一原则。

但当你必须要使用new 和delete时，你不得不控制C++中的内存分配。你需要用一个全局的new 和delete来代替系统的内存分配符，并且一个类一个类的重载new 和delete。

一个防止堆破碎的通用方法是从不同固定大小的内存持中分配不同类型的对象。对每个类重载new 和delete就提供了这样的控制。

重载全局的new 和delete 操作符
可以很容易地重载new 和 delete 操作符，如下所示:

void * operator new(size_t size)
{
    void *p = malloc(size);
    return (p);
}
void operator delete(void *p);
{
    free(p);
} 

这段代码可以代替默认的操作符来满足内存分配的请求。出于解释C++的目的，我们也可以直接调用malloc() 和free()。
 
为单个类的的new 和delete 操作符重载
 
 
也可以对单个类的new 和 delete 操作符重载。这是你能灵活的控制对象的内存分配。

class TestClass {
    public:
        void * operator new(size_t size);
        void operator delete(void *p);
        // .. other members here ...
};

void *TestClass::operator new(size_t size)
{
    void *p = malloc(size);  // Replace this with alternative allocator
    return (p);
}
void TestClass::operator delete(void *p)
{
    free(p);  // Replace this with alternative de-allocator
} 

所有TestClass 对象的内存分配都采用这段代码。更进一步，任何从TestClass 继承的类也都采用这一方式，除非它自己也重载了new 和 delete 操作符。通过重载new 和 delete 操作符的方法，你可以自由地采用不同的分配策略，从不同的内存池中分配不同的类对象。

为单个的类重载 new[ ] 和 delete[ ] 
必须小心对象数组的分配。你可能希望调用到被你重载过的new 和 delete 操作符，但并不如此。内存的请求被定向到全局的new[ ]和delete[ ] 操作符，而这些内存来自于系统堆。

C++将对象数组的内存分配作为一个单独的操作，而不同于单个对象的内存分配。为了改变这种方式，你同样需要重载new[ ] 和 delete[ ]操作符。

class TestClass {
    public:
        void * operator new[ ](size_t size);
        void operator delete[ ](void *p);
        // .. other members here ..
};
void *TestClass::operator new[ ](size_t size)
{
    void *p = malloc(size);
    return (p);
}
void TestClass::operator delete[ ](void *p)
{
    free(p);
}
int main(void)
{
    TestClass *p = new TestClass[10];
    
    // ... etc ...
    
    delete[ ] p;
} 

但是注意：对于多数C++的实现，new[]操作符中的个数参数是数组的大小加上额外的存储对象数目的一些字节。在你的内存分配机制重要考虑的这一点。你应该尽量避免分配对象数组，从而使你的内存分配策略简单。 

http://www.zdnet.com.cn/developer/code/story/0,3800066897,39141329-1,00.htm

水滴石穿C语言之内存使用
http://www.pcdog.com/p/html/2004124/41220041340_1.htm

 

问题：内存使用

　　有人写了一个将整数转换为字符串的函数：

char *itoa (int n)
{
　char retbuf[20];
　sprintf(retbuf, "%d", n);
　return retbuf;
} 

　　如果我调用这个函数：char *str5 = itoa(5)，str5会是什么结果呢？

　　答案分析：

　　答案是不确定，可以确定的是肯定不是我们想要的 “5”。

　　 retbuf定义在函数体中，是一个局部变量，它的内存空间位于栈（stack）中的某个位置，其作用范围也仅限于在itoa()这个函数中。当itoa()函数退出时，retbuf在调用栈中的内容将被收回，这时，这块内存地址可能存放别的内容。因此将retbuf这个局部变量返回给调用者是达不到预期的目的的。

　　那么如何解决这个问题呢，不用担心，方法不但有，而且还不止一个，下面就来阐述三种能解决这个问题的办法：

　　1)、在itoa()函数内部定义一个static char retbuf[20]，根据静态变量的特性，我们知道，这可以保证函数返回后retbuf的空间不会被收回，原因是函数内的静态变量并不是放在栈中，而是放在程序中一个叫“.bss”段的地方，这个地方的内容是不会因为函数退出而被收回的。

　　这种办法确实能解决问题，但是这种办法同时也导致了itoa()函数变成了一个不可重入的函数（即不能保证相同的输入肯定有相同的输出），另外， retbuf [] 中的内容会被下一次的调用结果所替代，这种办法不值得推荐。

　　2)、在itoa()函数内部用malloc() 为retbuf申请内存，并将结果存放其中，然后将retbuf返回给调用者。由于此时retbuf位于堆（heap）中，也不会随着函数返回而释放，因此可以达到我们的目的。

　　但是有这样一种情况需要注意：itoa()函数的调用者在不需要retbuf的时候必须把它释放，否则就造成内存泄漏了，如果此函数和调用函数都是同一个人所写，问题不大，但如果不是，则比较容易会疏漏此释放内存的操作。

　　3)、将函数定义为char *itoa（int n， char *retbuf），且retbuf的空间由调用者申请和释放，itoa()只是将转换结果存放到retbuf而已。

　　这种办法明显比第一、二种方法要好，既避免了方法1对函数的影响，也避免了方法2对内存分配释放的影响，是目前一种比较通行的做法。

　　扩展分析：

　　其实就这个问题本身而言，我想大家都可以立刻想到答案，关键在于对内存这种敏感资源的正确和合理地利用，下面对内存做一个简单的分析：

　　1)、程序中有不同的内存段，包括：

　　.data - 已初始化全局/静态变量，在整个软件执行过程中有效；

　　.bss - 未初始化全局/静态变量，在整个软件执行过程中有效；

　　.stack - 函数调用栈，其中的内容在函数执行期间有效，并由编译器负责分配和收回；

　　.heap - 堆，由程序显式分配和收回，如果不收回就是内存泄漏。

　　2)、自己使用的内存最好还是自己申请和释放。

　　这可以说是一个内存分配和释放的原则，比如说上面解决办法的第二种，由itoa()分配的内存，最后由调用者释放，就不是一个很好的办法，还不如用第三种，由调用者自己申请和释放。另外这个原则还有一层意思是说：如果你要使用一个指针，最好先确信它已经指向合法内存区了，如果没有就得自己分配，要不就是非法指针访问。很多程序的致命错误都是访问一个没有指向合法内存区的指针，这也包括空指针。

问题：内存分配 & sizeof 

　　我使用sizeof来计算一个指针变量，我希望得到这个指针变量所分配的内存块的大小，可以吗？

Char *p = NULL;
int nMemSize = 0;
…
p = malloc(1024);
nMemSize = sizeof(p); 

　　答案与分析： 

　　答案是达不到你的要求，sizeof只能告诉你指针本身占用的内存大小。指针所指向的内存，如果是malloc分配的，sizeof 是没有办法知道的。换句话说，malloc分配的内存是没有办法向内存管理模块进行事后查询的，当然你可以自己编写代码来维护。

　　 问题：栈内存使用 

　　下面程序运行有什么问题？

char *GetString(void)
{
　char p[] = "hello world";
　return p;// 编译器将提出警告
}

void Test4(void)
{
　char *str = NULL;
　str = GetString();// str 的内容是垃圾
　cout<< str << endl;
} 

　　答案与分析：

　　返回栈内存，内存可能被销毁，也可能不被销毁，但是，出了作用域之后已被标记成可被系统使用，所以，乱七八糟不可知内容，当然，返回的指针的内容，应该是不变的，特殊时候是有用的，比如，可以用来探测系统内存分配规律等等。

　　问题：内存使用相关编程规范 

　　我想尽可能地避免内存使用上的问题，有什么捷径吗？

　　答案与分析：

　　除非做一件从没有人做过的事情，否则，都是有捷径可言的，那就是站在前人的肩膀上，现在各个大公司都有自己的编码规范，这些规范凝聚了很多的经验和教训，有较高的使用价值，鉴于这些规范在网上流传很多，这里我就不再列出了，感兴趣的，推荐参考林锐的《高质量C/C++编程指南》。
C++入门解惑——初探指针
关键字     C++ 入门 指针 数组 动态内存 
  
．形形色色的指针

 

      前一章我们引入了指针及其定义，这一节我们继续研究各种不同的指针及其定义方式（注：由于函数指针较为特殊，本章暂不作讨论，但凡出现“指针”一词，如非特别说明均指数据指针）。

1）指向指针的指针

我们已经知道，指针变量是用于储存特定数据类型地址的变量，假如我们定义

int *pInt;

      那么，pInt为一个指向整型变量的指针变量。好，我们把前面这句话的主干提取出来，就是：pInt为变量。既然pInt是变量，在内存中就会有与之对应的存放数据的地址值，那么理论上也就应该有对应的指针来存储，嗯，实际上也如此，我们可以向这样来定义可以指向变量pInt的指针：

int **pIntPtr;

      按前一章的方法很好理解这样的定义：**pIntPtr是一个int类型，则去掉一个*，*pIntPtr就是指向int的指针，再去一个*，我们最终得到的pIntPtr就是一个“指向int型指针变量的指针变量”，呵呵，是点拗口，不管怎么说我们现在可以写：

pIntPtr = &pInt;

      令其指向pInt变量，而*pIntPtr则可以得回pInt变量。假如pInt指向某个整型变量如a，*pInt可以代表a，因此*(*pIntPtr)此时也可以更间接地得到a，当然我们如果省去括号，写成**pIntPtr也是可以的。

      以此类推，我们还可以得到int ***p这样的“指向指向指向int型变量的指针的指针的指针”，或者再复杂：int ****p，“指向指向指向指向……”喔，说起来已经很晕了，不过原理摆在这里，自己类比一下即可。

2）指针与常量

      C++的常量可以分两种，一种是“文本”常量，比如我们程序中出现的18，3.14，’a’等等；另一种则是用关键字const定义的常量。大多数时候可以把这两种常量视为等同，但还是有一些细微差别，例如，“文本”常量不可直接用&寻找其在内存中对应的地址，但const定义的常量则可以。也就是说，我们不能写&18这样的表达式，但假如我们定义了

const int ClassNumber = 18;

      则我们可以通过&ClassNumber表达式得到常量ClassNumber的地址（不是常数18的地址！）。其实在存储特点上常量与变量基本是一样的（有对应的地址，并且在对应地址上存有相应的值），我们可以把常量看作一种“受限”的变量：只可读不可写。既然它们如此相似，而变量有对应的指针，那么常量也应该有其对应的指针。比如，一个指向int型常量的指针pConstInt定义如下：

const int *pConstInt；

      它意味着*pConstInt是一个整型常量，因此pConstInt就是一个指向整型常量的指针。我们就可以写

pConstInt = &ClassNumber;

      来令pConstInt指向常量ClassNumber. 给你三秒钟，请判断pConstInt是常量还是变量。1，2，3！OK，假如你的回答是变量，那么说明你对常量变量的概念认识得还不错，否则应该翻本C++的书看看const部分的内容。

      唔，既然int、float、double甚至我们自己定义的class都可以有对应的常量类型，那么指针应该也有常量才对，现在的问题是，我们应该如何定义一个指针常量呢？我们通常定义常量的作法是在类型名称前面加上const，像const int a等等，但如果在指针定义前面加const，由于*是右结合的，语义上计算机会把const int *p 视为 (const int) (*p)（括号是为了突出其结合形式所用，但不是合法的C++语法），即*p是一个const int型常量，p就为一个指向const int常量的指针。也就是说，我们所加的const并非修饰p，而是修饰*p，换成int const *p又如何呢？噢，这和const int *p没有区别。为了让我们的const能够修饰到p，我们必须越过*号的阻挠将const送到p跟前，假如我们先在前面定义了一个int变量a，则语句

int * const p = &a;

      就最终如我们所愿地定义了一个指针常量p，它总是表示a的地址，也就是说，它恒指向变量a.

      嗯，小结一下：前面我们讲了两种指针，一种是“指向常量的指针变量”，而之后是“指向变量的指针常量”，它们定义的区别就在于const所修饰的是*p还是p. 同样，还会有“指向常量的指针常量”，显然，必须要有两个const，一个修饰*p，另一个修饰p：

const int * const p = &ClassNumber;

      以*为界，我们同样很好理解：*表示我们声明的是指针，它前面的const int表示它指向某个整型常量，后面的const表示它是的个常量指针。为方便区别，许多文章都介绍了“从右到左”读法，其中把“*”读作“指针”：

const int *p1 = &ClassNumber; // p1是一个指针，它指向int型常量

int * const p2 = &a;          // p2是一个指针常量，它指向int型变量

const int * const p3 = &ClassNumber; // p3是一个指针常量，它指向int型常量

      好了，我们前面定义指针常量时，受到了*号右结合的困扰，使得前置的const修饰不到p，假如*号能与int结合起来（就像前一章所说的“前置派”的理解），成为一种“指向整型指针的类型”，如：

const (int*) p;

      const就可以修饰到p了。但C++的括号只能用于改变表达式的优先级而不能改变声明语句的结合次序，能不能想出另一种方法来实现括号的功能呢？答案是肯定的：使用关键字typedef.

      typedef的一个主要作用是将多个变量/常量修饰符捆梆起来作为一种混合性的新修饰符，例如要定义一个无符号的整型常量，我们要写

const unsigned int ClassNumber = 18;

      但我们也可以先用typedef将“无符号整型常量”定义成一个特定类型：

typedef const unsigned int ConstUInt;

这样我们只须写

ConstUInt ClassNumber = 18;

就可以达到与前面等价的效果。咋看似乎与我们关注的内容没有关系，其实typedef的“捆梆”就相当于加了括号，假如，我们定义：

typedef int * IntPtr;

      这意味着什么？这意味着IntPtr是一个“整型指针变量”类型，这可是前面所没有出现过的新复合类型，实际上这才是上章“前置派”所理解的“int*”类型：我们当初即使写

int* p1, p2;

虽然有了空格作为我们视觉上的区分，但不幸的是编译器不吃这一套，仍会把*与p1结合，变成

int (*p1), p2;

所以可怜的p2无依无靠只得成为一个整型变量。但现在我们写

IntPtr p1, p2;

      结论就不一样了：有了typedef的捆梆，IntPtr已经成为了名符其实的整型指针类型，所以p1，p2统统成为了货真介实的指针。那么我们写

const IntPtr p;

      噢，不好意思，编译出错了：没有初始化常量p……咦，看见了没有？在const IntPtr的修饰下p已经成为指针常量了（而不是const int *p这样的指向常量的指针），哦，明白了，由于typedef的捆梆，const与IntPtr都同心协力地修饰p，即理解为：

(const)  (int *) p;

而不是前面的

(const int)  (*p);

      所以，不要小瞧了typedef，不要随意将它看作是一个简单的宏替换。事实上《C++ Primer》就曾经出了这样的类似考题，大约也是考你：const IntPtr p中的p是指向const int的指针呢还是指向int的指针常量。我知道现在你可以毫不犹豫地正确地回答这个问题了。

BTW：当初第一次看到的时候，我也是毫不犹豫，可惜答错了^_^

3．指针、动态内存、数组

      我们上一章谈到变量时已经知道，变量实际上就是编译系统为我们程序分配的一块内存，编译器会将变量名称与这块内存正确地联系起来以供我们方面地读写。设想一下，假如一块这样的存储单元没有“变量名”，我们应该如何访问它呢？噢，如果有这个单元的地址，我们通过*运算符也可以得回该对应的变量。

变量定义可以看作两个功能的实现：1.分配内存；2.将内存与变量名联系起来。

      按前面所说，如果知道地址，也可以不需要变量名，所以上两个功能如果变成：1.分配内存；2.将分配所得的内存的地址保存起来；

      理论上也可以实现上面的功能。在C++中，我们使用new运算符就可以实现第二种方法。new表达式会为我们分配一适当的内存，并且返会该内存的首地址（确切说应该是一个指针）。在表达式中，关键字new后面通常紧跟着数据类型，以指示分配内存的大小及返回的指针类型，例如new int表达式会为我们分配一块整型变量所需的内存（32位机上通常为4字节），然后这个表达式的值就是一个指向该内存的整型指针值。因此我们可以写：

int *p;

p = new int;    // 分配一块用于存储一个整型变量的内存，并将地址赋给指针p

这样我们就可以通过*p来对这块“没有变量名”的内存进行相同的操作。

      前面我们仅仅在内存中分配了一个整型存储单元，我们还可以分配一块能存储多个整型值的内存，方法是在int后面加上用“[ ]”括起来的数字，这个数字就是你想分配的单元数目。如：

int *p;

p = new int[18];  // 分配一块用于存储18个整型变量的内存，并将首地址赋给指针p

      但这时候我们用*p只能对18个整型单元的第一个进行存取，如何访问其它17个单元呢？由于这些单元都是连续存放的，所以我们只要知道首地址的值以及每个整型变量所占用的空间，就可以计算出其它17个单元的起始地址值。在C++中，我们甚至不必为“每个整形变量所占空间”这样的问题所累，因为C++可以“自动地”为我们实现这一点，我们只需要告诉它我们打算访问的是相对当前指针值的第几个单元就可以了。

      这一点通过指针运算可以实现，例如，按前面的声明，现在p已经指向18块存储单元的第一块，如果我想访问第二块，也就是p当前所指的下一块内存呢？很简单，只要写p+1，这个表达式的结果就会神奇地得出第二块内存单元的地址，如果你的机器是32位，那么你感兴趣的话可以打印一下p的地址值与p+1的地址值，你会发现它们之间相差的是4个字节，而不是1个，编译器已经自动为我们做好了转换的工作：它会自动将1乘上指针所指的一个变量（整型变量）所占的内存（4字节）。于是我们如果想要给第二内存单元赋值为3 ，则只须写：

*(p + 1) = 3;   // 注意：*号优先级比+号要高，所以要加上括号

要打印的时候就写：

cout << *(p+1);  // 输出3

总之这些和一般的变量一样使用没有什么两样了。我们当然也可以将它的地址值赋给另外的指针变量：

int *myPtr;

myPtr = p + 1;       // OK，现在myPtr就指向第二内存单元的地址

也可以进行自加操作：

myPtr++;       // 按上面的初值，自加后myPtr已经指向第三内存单元的地址

*myPtr = 18;    // 现在将第三个内存单元赋予整型值18，也就相当于*(p + 2) = 18

      到目前为止一切都很好，但*(p +1)这样的写法太麻烦，C++为此引入了简记的方法，就是“[ ]”运算符（当初定义的时候也用过它哦）：要访问第二单元内存，我们只需要写p[1]就可以，它实际上相当于*(p + 1)：

p[1] = 3;      // *(p + 1) = 3;

cout << p[15];   // cout << *(p + 15);

p[0] = 6;      // *(p + 0) = 6;  也就是 *p = 6;

为了说明“[ ]”与*(… + …)的等效性，下面再看一组奇怪的例子：

1[p] = 3;      // *(1 + p) = 3;

cout << 15[p];   // cout << *(15 + p);

0[p] = 6;       // *(0 + p) = 6; 也就是 *p = 6;

      看起来是不是很怪异？其实这一组只不过交换了一下加数位置而已，功能与上一组是完全一样的。

      前面我们介绍了一种分配内存的新方法：利用new运算符。new运算符分配的内存除了没有变量分配时附带有的变量名外，它与变量分配还有一个重要的区别：new运算符是在堆(heap)中分配空间，而通常的变量定义是在栈（stack）上分配内存。

      堆和栈是程序内存的两大部分，初学可以不必细究其异同，有一点需要明白的是，在栈上分配的内存系统会自动地为其释放，例如在函数结束时，局部变量将不复存在，就是系统自动清除栈内存的结果。但堆中分配的内存则不然：一切由你负责，即使你退出了new表达式的所处的函数或者作用域，那块内存还处于被使用状态而不能再利用。好处就是如果你想在不同模块中共享内存，那么这一点正合你意，坏处是如果你不打算再利用这块内存又忘了把它释放掉，那么它就会霸占你宝贵的内存资源直到你的程序退出为止。

      如何释放掉new分配的堆内存？答案是使用delete算符。delete的大概是C++中最简单的部分之一（但也很容易粗心犯错！），你只要分清楚你要释放的是单个单元的内存，还是多个单元的内存，假如：

int *p = new int;        // 这里把分配语句与初始化放在一起，效果和前面是一样的

…  // 使用*p

delete p;     // 释放p所指的内存，即用new分配的内存

如果是多个单元的，则应该是这样：

int *p = new int[18];

… // 使用

delete[] p;    // 注意，由于p指向的是一块内存，所以delete后要加“[]”

// 以确保整块内存都被释放，没有“[]”只会释放p指的第一块内存

      刚才我们是在堆中分配连续内存，同样，在栈上也可以分配边续内存，例如我们同样要分配18个单元的整型内存空间，并将首地址赋予指针a，则定义如下：

int a[18];

      类似于前面用new的版本，系统会在栈上分配18个整型内存单元，并将首地址赋予指针a，我们同样可以通过“[ ]”操作符或者古老的“*（… + …）”来实现对它的访问。需要注意的是a是一个指向整型的指针常量类型，不可以再对a赋值使其指向其它变量。同样，由于是在栈中分配内存，释放工作也不必由我们操心。由于a“看起来”包含了许多个相同类型的变量，因此C++将其称为数组。

      由上面看来，栈分配的数组似乎比堆分配要简单好用，但栈分配有一个缺点，就是必须在编译时刻确定内存的大小，也就是说，假如我要写一个排序程序，每次参加排序的元素个数都不一样，但我不能写

int number;

cin >> number;

int a[number];   // 错误，number是变量，而作为栈上分数空间的数组a的大小必须在编译时就决定

但我可以写

int number;

cin >> number;

int *a = new int[number];       // 没有问题，堆空间分配可以在程序运行时才确定

当然最后别忘了释放就成了：

delete[] a;

      由于堆内存的分配比栈内存具有更大的灵活性，可以在程序执行期动态决定分配空间的大小，所以又称为动态内存。
C++中动态内存分配引发问题的解决方案
http://www.pcdog.com/p/html/2004124/41220041343_1.htm
假设我们要开发一个String类，它可以方便地处理字符串数据。我们可以在类中声明一个数组，考虑到有时候字符串极长，我们可以把数组大小设为200，但一般的情况下又不需要这么多的空间，这样是浪费了内存。对了，我们可以使用new操作符，这样是十分灵活的，但在类中就会出现许多意想不到的问题，本文就是针对这一现象而写的。现在，我们先来开发一个Wrong类，从名称上看出，它是一个不完善的类。的确，我们要刻意地使它出现各种各样的问题，这样才好对症下药。好了，我们开始吧！

 

　　Wrong.h: 

#ifndef WRONG_H_
#define WRONG_H_
class Wrong
{
private:
char * str; //存储数据 
int len; //字符串长度 

public:
Wrong(const char * s); //构造函数 
Wrong(); // 默认构造函数 
~Wrong(); // 析构函数
friend ostream & operator＜＜(ostream & os,const Wrong& st);
};
#endif

Wrong.cpp:

#include ＜iostream＞
#include ＜cstring＞ 
#include "wrong.h"
using namespace std;
Wrong::Wrong(const char * s)
{
len = strlen(s); 
str = new char[len + 1];
strcpy(str, s); 

}//拷贝数据 

Wrong::Wrong()
{
len =0;
str = new char[len+1];
str[0]='/0';

}

Wrong::~Wrong()
{
cout＜＜"这个字符串将被删除："＜＜str＜＜'/n';//为了方便观察结果，特留此行代码。 
delete [] str;
}

ostream & operator＜＜(ostream & os, const Wrong & st)
{
os ＜＜ st.str;
return os;
}

test_right.cpp:

#include ＜iostream＞
#include ＜stdlib.h＞
#include "Wrong.h"
using namespace std;
int main()
{
Wrong temp("天极网");
cout＜＜temp＜＜'/n'; 
system("PAUSE"); 
return 0;
} 

　　运行结果：

　　天极网

　　请按任意键继续. . .

　　大家可以看到，以上程序十分正确，而且也是十分有用的。可是，我们不能被表面现象所迷惑！下面，请大家用test_wrong.cpp文件替换test_right.cpp文件进行编译，看看结果。有的编译器可能就是根本不能进行编译！

　　test_wrong.cpp:

#include ＜iostream＞
#include ＜stdlib.h＞
#include "Wrong.h"
using namespace std;
void show_right(const Wrong&);
void show_wrong(const Wrong);//注意，参数非引用，而是按值传递。 
int main()
{
Wrong test1("第一个范例。");
Wrong test2("第二个范例。");
Wrong test3("第三个范例。");
Wrong test4("第四个范例。"); 
cout＜＜"下面分别输入三个范例：/n";
cout＜＜test1＜＜endl;
cout＜＜test2＜＜endl;
cout＜＜test3＜＜endl;
Wrong* wrong1=new Wrong(test1);
cout＜＜*wrong1＜＜endl;
delete wrong1;
cout＜＜test1＜＜endl;//在Dev-cpp上没有任何反应。
cout＜＜"使用正确的函数："＜＜endl;
show_right(test2);
cout＜＜test2＜＜endl;
cout＜＜"使用错误的函数："＜＜endl;
show_wrong(test2);
cout＜＜test2＜＜endl;//这一段代码出现严重的错误！ 
Wrong wrong2(test3);
cout＜＜"wrong2: "＜＜wrong2＜＜endl;
Wrong wrong3;
wrong3=test4;
cout＜＜"wrong3: "＜＜wrong3＜＜endl;
cout＜＜"下面，程序结束，析构函数将被调用。"＜＜endl; 
return 0;
}
void show_right(const Wrong& a)
{
cout＜＜a＜＜endl;
}
void show_wrong(const Wrong a)
{
cout＜＜a＜＜endl;
} 

　　运行结果：

　　下面分别输入三个范例：

　　第一个范例。
　　第二个范例。
　　第三个范例。

　　第一个范例。

　　这个字符串将被删除：第一个范例。

　　使用正确的函数：
　　
　　第二个范例。
　　第二个范例。

　　使用错误的函数：
　　第二个范例。

　　这个字符串将被删除：第二个范例。

　　这个字符串将被删除：?=
　　?=

　　wrong2: 第三个范例。
　　wrong3: 第四个范例。

　　下面，程序结束，析构函数将被调用。

　　这个字符串将被删除：第四个范例。

　　这个字符串将被删除：第三个范例。

　　这个字符串将被删除：?=

　　这个字符串将被删除：x =

　　这个字符串将被删除：?=

　　这个字符串将被删除：

　　现在，请大家自己试试运行结果，或许会更加惨不忍睹呢！下面，我为大家一一分析原因。

首先，大家要知道，C＋＋类有以下这些极为重要的函数：

　　一：复制构造函数。

　　二：赋值函数。

　　我们先来讲复制构造函数。什么是复制构造函数呢？比如，我们可以写下这样的代码：Wrong test1(test2);这是进行初始化。我们知道，初始化对象要用构造函数。可这儿呢？按理说，应该有声明为这样的构造函数：Wrong(const Wrong &);可是，我们并没有定义这个构造函数呀？答案是，C＋＋提供了默认的复制构造函数，问题也就出在这儿。

　　（1）：什么时候会调用复制构造函数呢？（以Wrong类为例。）

　　在我们提供这样的代码：Wrong test1(test2)时，它会被调用；当函数的参数列表为按值传递，也就是没有用引用和指针作为类型时，如：void show_wrong(const Wrong)，它会被调用。其实，还有一些情况，但在这儿就不列举了。

　　（2）：它是什么样的函数。

　　它的作用就是把两个类进行复制。拿Wrong类为例，C＋＋提供的默认复制构造函数是这样的：

Wrong(const Wrong& a)
{
str=a.str;
len=a.len;
} 

　　在平时，这样并不会有任何的问题出现，但我们用了new操作符，涉及到了动态内存分配，我们就不得不谈谈浅复制和深复制了。以上的函数就是实行的浅复制，它只是复制了指针，而并没有复制指针指向的数据，可谓一点儿用也没有。打个比方吧！就像一个朋友让你把一个程序通过网络发给他，而你大大咧咧地把快捷方式发给了他，有什么用处呢？我们来具体谈谈：

　　假如，A对象中存储了这样的字符串：“C＋＋”。它的地址为2000。现在，我们把A对象赋给B对象：Wrong B=A。现在，A和B对象的str指针均指向2000地址。看似可以使用，但如果B对象的析构函数被调用时，则地址2000处的字符串“C＋＋”已经被从内存中抹去，而A对象仍然指向地址2000。这时，如果我们写下这样的代码：cout＜＜A＜＜endl;或是等待程序结束，A对象的析构函数被调用时，A对象的数据能否显示出来呢？只会是乱码。而且，程序还会这样做：连续对地址2000处使用两次delete操作符，这样的后果是十分严重的！

　　本例中，有这样的代码：

Wrong* wrong1=new Wrong(test1);
cout＜＜*wrong1＜＜endl;
delete wrong1; 

　　假设test1中str指向的地址为2000,而wrong中str指针同样指向地址2000，我们删除了2000处的数据，而test1对象呢？已经被破坏了。大家从运行结果上可以看到，我们使用cout＜＜test1时，一点反应也没有。而在test1的析构函数被调用时，显示是这样：“这个字符串将被删除：”。

　　再看看这段代码：

cout＜＜"使用错误的函数："＜＜endl;
show_wrong(test2);
cout＜＜test2＜＜endl;//这一段代码出现严重的错误！  

　　show_wrong函数的参数列表void show_wrong(const Wrong a)是按值传递的，所以，我们相当于执行了这样的代码：Wrong a=test2;函数执行完毕，由于生存周期的缘故，对象a被析构函数删除，我们马上就可以看到错误的显示结果了：这个字符串将被删除：?=。当然，test2也被破坏了。解决的办法很简单，当然是手工定义一个复制构造函数喽！人力可以胜天！

Wrong::Wrong(const Wrong& a)
{
len=a.len;
str=new char(len+1);
strcpy(str,a.str);
} 

　　我们执行的是深复制。这个函数的功能是这样的：假设对象A中的str指针指向地址2000，内容为“I am a C++ Boy!”。我们执行代码Wrong B=A时，我们先开辟出一块内存，假设为3000。我们用strcpy函数将地址2000的内容拷贝到地址3000中，再将对象B的str指针指向地址3000。这样，就互不干扰了。

　　大家把这个函数加入程序中，问题就解决了大半，但还没有完全解决，问题在赋值函数上。我们的程序中有这样的段代码：

Wrong wrong3;
wrong3=test4; 

　　经过我前面的讲解，大家应该也会对这段代码进行寻根摸底：凭什么可以这样做：wrong3=test4？？？原因是，C＋＋为了用户的方便，提供的这样的一个操作符重载函数：operator=。所以，我们可以这样做。大家应该猜得到，它同样是执行了浅复制，出了同样的毛病。比如，执行了这段代码后，析构函数开始大展神威^_^。由于这些变量是后进先出的，所以最后的wrong3变量先被删除：这个字符串将被删除：第四个范例。很正常。最后，删除到test4的时候，问题来了：这个字符串将被删除：?=。原因我不用赘述了，只是这个赋值函数怎么写，还有一点儿学问呢！大家请看：

　　平时，我们可以写这样的代码：x=y=z。（均为整型变量。）而在类对象中，我们同样要这样，因为这很方便。而对象A=B=C就是A.operator=(B.operator=(c))。而这个operator=函数的参数列表应该是：const Wrong& a，所以，大家不难推出，要实现这样的功能，返回值也要是Wrong&，这样才能实现A＝B＝C。我们先来写写看：

Wrong& Wrong::operator=(const Wrong& a)
{
delete [] str;//先删除自身的数据
len=a.len;
str=new char[len+1];
strcpy(str,a.str);//此三行为进行拷贝
return *this;//返回自身的引用
} 

　　是不是这样就行了呢？我们假如写出了这种代码：A=A，那么大家看看，岂不是把A对象的数据给删除了吗？这样可谓引发一系列的错误。所以，我们还要检查是否为自身赋值。只比较两对象的数据是不行了，因为两个对象的数据很有可能相同。我们应该比较地址。以下是完好的赋值函数：

Wrong& Wrong::operator=(const Wrong& a)
{
if(this==&a)
return *this;
delete [] str;
len=a.len;
str=new char[len+1];
strcpy(str,a.str);
return *this;
} 

　　把这些代码加入程序，问题就完全解决，下面是运行结果：

　　下面分别输入三个范例：

　　第一个范例
　　第二个范例
　　第三个范例

　　第一个范例

　　这个字符串将被删除：第一个范例。

　　第一个范例

　　　使用正确的函数：

　　第二个范例。

　　第二个范例。

　　　使用错误的函数：

　　第二个范例。

　　这个字符串将被删除：第二个范例。

　　第二个范例。

　　wrong2: 第三个范例。
　　wrong3: 第四个范例。

　　下面，程序结束，析构函数将被调用。

　　这个字符串将被删除：第四个范例。
　　这个字符串将被删除：第三个范例。
　　这个字符串将被删除：第四个范例。
　　这个字符串将被删除：第三个范例。
　　这个字符串将被删除：第二个范例。
　　这个字符串将被删除：第一个范例。

　　关于动态内存分配的问题就介绍到这儿，希望大家都能热爱编程，热爱C＋＋！