.NET六大剑客：栈、堆、值类型、引用类型、装箱和拆箱

一.“堆”，“栈”专区

这两个字我相信大家太熟悉了，甚至于米饭是什么？不知道。。。“堆”，“栈”是什么？哦，这个知道。。。

之前我也写过一篇堆栈的文章，不过写的不深刻，剖析的也不全面，所以今天也参考了一些大牛的资料。

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

一个由C/C++编译的程序占用的内存分为以下几个部分

1、栈区（stack）— 由编译器自动分配释放，存放函数的参数值，局部变量的值等。其

操作方式类似于数据结构中的栈。栈是一个内存数组，是一个LIFO（last-in first-out，后进先出）的数据结构。

2、堆区（heap） — 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回

收。注意它与数据结构中的堆是两回事。堆是一块内存区域，在堆里可以分配大块的内存用于存储某类型的数据。

与栈不同，堆里的内存可以任意顺序存入和移除。

虽然程序可以在堆里保存数据，但并不能显示地删除它们。CLR的自动GC（Garbage Collector，垃圾收集器）再判断出程序的

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"

优化成一个地方。

}

三、堆和栈的理论知识

3.1申请方式

stack:

由系统自动分配。例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空

间

heap:

需要程序员自己申请，并指明大小，在c中malloc函数

如p1 = (char *)malloc(10);

在C++中用new运算符

如p2 = new char[10];

但是注意p1、p2本身是在栈中的。

3.2

申请后系统的响应

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢

出。

堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，

会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表

中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的

首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。

另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部

分重新放入空闲链表中。

3.3申请大小的限制

栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意

思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有

的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将

提示overflow。因此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储

的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小

受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

3.4申请效率的比较：

栈由系统自动分配，速度较快。但程序员是无法控制的。

堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.

另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是

直接在进程的地址空间中保留一块内存，虽然用起来最不方便。但是速度快，也最灵活。

3.5堆和栈中的存储内容

栈：在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可

执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈

的，然后是函数中的局部变量。注意静态变量是不入栈的。

当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地

址，也就是主函数中的下一条指令，程序由该点继续运行。

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

3.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读取字符，显然慢了。

四.为了理解栈和堆，让我们通过以下的代码来了解背后到底发生了什么。

1publicvoidMethod1()2{34//Line 15inti=4;678//Line 29inty=2;101112//Line 313class1 cls1 =newclass1();14}

代码只有三行，现在我们可以一行一行地来了解到底内部是怎么来执行的。

Line 1：当这一行被执行后，编译器会在栈上分配一小块内存。栈会在负责跟踪你的应用程序中是否有运行内存需要Line 2：现在将会执行第二步。正如栈的名字一样，它会将此处的一小块内存分配叠加在刚刚第一步的内存分配的顶部。你可以认为栈就是一个一个叠加起来的房间或盒子。在栈中，数据的分配和解除都会通过LIFO (Last In First Out)即先进后出的逻辑规则进行。换句话说，也就是最先进入栈中的数据项有可能最后才会出栈。Line 3：在第三行中，我们创建了一个对象。当这一行被执行后，.NET会在栈中创建一个指针，而实际的对象将会存储到一个叫做“堆”的内存区域中。“堆”不会监测运行内存，它只是能够被随时访问到的一堆对象而已。不同于栈，堆用于动态内存的分配。这里需要注意的另一个重要的点是对象的引用指针是分配在栈上的。例如：声明语句 Class1 cls1; 其实并没有为Class1的实例分配内存，它只是在栈上为变量cls1创建了一个引用指针（并且将其默认职位null）。只有当其遇到new关键字时，它才会在堆上为对象分配内存。离开这个Method1方法时（the fun）：现在执行控制语句开始离开方法体，这时所有在栈上为变量所分配的内存空间都会被清除。换句话说，在上面的示例中所有与int类型相关的变量将会按照“LIFO”后进先出的方式从栈中一个一个地出栈。需要注意的是：这时它并不会释放堆中的内存块，堆中的内存块将会由垃圾回收器稍候进行清理。

现在我们许多的开发者朋友一定很好奇为什么会有两种不同类型的存储？我们为什么不能将所有的内存块分配只到一种类型的存储上？

如果你观察足够仔细，基元数据类型并不复杂，他们仅仅保存像 ‘int i = 0’这样的值。对象数据类型就复杂了，他们引用其他对象或其他基元数据类型。换句话说，他们保存其他多个值的引用并且这些值必须一一地存储在内存中。对象类型需要的是动态内存而基元类型需要静态内存。如果需求是动态内存的话，那么它将会在堆上为其分配内存，相反，则会在栈上为其分配。栈的存取速度比堆快。

最后给大家一个堆和栈的形象比喻：

使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就

走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自

由度小。

使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由

度大。

二.值类型和引用类型

CLR支持两种类型，引用类型和值类型。这两种类型的不同之处是，他们在.NET类层次结构中的位置不同，那么.NET为其分配的内存的方式也是不同的。

咳咳！直白点儿说：值类型就是现金，要用直接用；引用类型是存折，要用还得先去银行取现。

声明一个值类型变量，编译器会在栈上分配一个空间，这个空间对应着该值类型变量，空间里存储的就是该变量的值。引用类型的实例分配在堆上，新建一个引用类型实例，得到的变量值对应的是该实例的内存分配地址，这就像您的银行账号一样。

C#的所有值类型均隐式派生自System.ValueType：

结构体：struct（直接派生于System.ValueType）；数值类型：整型：sbyte（System.SByte的别名），short（System.Int16），int（System.Int32），long （System.Int64），byte（System.Byte），ushort（System.UInt16），uint （System.UInt32），ulong（System.UInt64），char（System.Char）；浮点型：float（System.Single），double（System.Double）；用于财务计算的高精度decimal型：decimal（System.Decimal）。bool型：bool（System.Boolean的别名）；用户定义的结构体（派生于System.ValueType）。枚举：enum（派生于System.Enum）；可空类型（派生于System.Nullable<T>泛型结构体，T?实际上是System.Nullable<T>的别名）。值类型（Value Type），值类型实例通常分配在线程的堆栈（stack）上，并且不包含任何指向实例数据的指针，因为变量本身就包含了其实例数据

C#有以下一些引用类型：

数组（派生于System.Array）用户用定义的以下类型：类：class（派生于System.Object）；接口：interface（接口不是一个“东西”，所以不存在派生于何处的问题。Anders在《C#PRogramming Language》中说，接口只是表示一种约定[contract]）；委托：delegate（派生于System.Delegate）。object（System.Object的别名）；字符串：string（System.String的别名）。可以看出：

引用类型与值类型相同的是，结构体也可以实现接口；引用类型可以派生出新的类型，而值类型不能；引用类型可以包含null值，值类型不能（可空类型功能允许将 null 赋给值类型）；引用类型变量的赋值只复制对对象的引用，而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时，将复制包含的值

再往深剖析就剖内存了，鄙人不懂所以就不写了！

三.装箱和拆箱

装箱（box)：把值类型对象转为引用类型的对象；

拆箱(unbox)：把引用类型对象转为值类型的对象。

C#装箱和拆箱原理：

装箱：

int age = 24;

object refAge= age;

可以看的出，第一条语句创建一个变量age，并将值放在托管栈中；

第二条语句将age的值赋给引用类型。它将值24放在托管堆中。

这个值类型包装为引用类型的过程，称为装箱。

拆箱：

相反，将引用类型转换为值类型的过程称为拆箱。拆箱将对对象强制转换为原来的类型。对前面的对象进行拆箱。

int newAge = (int) refAge;

string newAge =(String) refAge;

拆箱的值必须和它要转换的目标的变量有相同的类型。

下面是我们常写的代码，那么在这个过程中，装箱和拆箱到底是怎么转换的呢?

int n = 2;

object obj = (object)n;//装箱，把数值类型int转换为引用类型object对象的。

int m = (int)obj;//拆箱，把引用类型的object转换为int类型。

我们可以看看C#代码被编译为中间语言IL，就很清楚装箱和拆箱的过程：

实际编码过程中到底哪些是装箱和拆箱呢？

1、引用类型之间不属于装箱和拆箱，装箱、拆箱必须是：值类型→引用类型或引用类型→值类型。

Person p=new Student();//这个叫隐式类型转换，不叫装箱。

Student stu=(Student)p;//这个叫显示类型转换，不叫拆箱。

2、方法重载时，如果具有该类型的重载，那么就不叫拆箱或装箱。

int n=10; Console.WriteLine(n);//没有发生装箱，因为方法重载。

3、接口与值类型之间的装箱与拆箱。

int n = 2;

IComparable c = n;

int m = (int)c;

Console.WriteLine(m.ToString());

要写一个高效的高性能的软件，要注意装箱和拆箱对应用程序造成的影响。个人建议少用！