Linux_内存分配中的堆和栈

1、什么是堆栈？

2、一道微软的笔试题。
3、自己写的两个关于堆栈的例子？
4、如何动态申请二维数组？

一、什么是堆栈？

1、内存分配

    一个由C/C++编译的程序占用的内存分为以下几个部分 
1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 
2、堆区（heap） — 一般由程序员分配释放 ， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。 
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域(BSS)。 - 程序结束后由系统释放 
4、文字常量区 — 常量字符串就是放在这里的。 程序结束后由系统释放 
5、程序代码区— 存放函数体的二进制代码。

    一个简单的例子

[html] view plaincopy
  1. //main.cpp   
  2. int a = 0;      /* 全局初始化区 */  
  3. char *p1;       /* 全局未初始化区 */  
  4. void main()   
  5. {   
  6.     int b;              /* 栈 */   
  7.     char s[] = "abc";   /* 栈 */  
  8.     char *p2;           /* 栈 */  
  9.     char *p3 = "123456";    /* 123456在常量区，p3在栈上 */  
  10.     static int c =0;        /* 全局（静态）初始化区 */  
  11.       
  12.     /* 分配得来得10和20字节的区域就在堆区 */  
  13.     p1 = (char *)malloc(10);   
  14.     p2 = (char *)malloc(20);   
  15.       
  16.     /* 123456放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方 */  
  17.     strcpy(p1, "123456");  
  18. }  

2、堆栈的理论知识

申请方式 

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

申请后系统的响应 

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

申请大小的限制 

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

二、一道微软笔试题

[html] view plaincopy
  1. 6 Which of following C++ code is correct?  (E)  
  2. (A) int f()  
  3.     {  
  4.         int* a = new int(3);  
  5.         return a;  
  6.     }  
  7. (B) int* f()  
  8.     {  
  9.         int a[3] = {1, 2, 3};  
  10.         return a;  
  11.     }  
  12. (C) vector<int> f()  
  13.     {  
  14.         vector<int> v(3);  
  15.         return v;  
  16.     }  
  17. (D) void f(int *ret)  
  18.     {  
  19.         int a[3] = {1, 2, 3};  
  20.         ret = a;  
  21.         return;  
  22.     }  
  23. (E) none of above  

根据上面的实例，我们来分析一下堆栈空间的使用情况。
(A) 是错误的，原因是函数声明中返回的是int，而实际返回的a是int*。现在让我们思考一下，如果在函数的声明修改为：int *f()。这样返回出去的指针指向的空间是否可用？  我们知道，使用new申请的动态空间是在堆上申请的，其申请和释放都是由程序员来操作的，所以在函数返回时，它不会随着函数的返回而释放。这一点与栈空间不同，在函数返回时，在该函数内部的申请的栈空间都将被系统释放。为了保证程序的安全性，该函数返回的栈空间指针是不可用的。但是实际上，我们可以使用任何一个栈空间上的指针去访问栈空间的。

(B)是错误的，原因上面提到了，int a[3] = {1, 2, 3} 是局部变量，其位于栈空间。在函数返回时，我们返回了指针a，如果在返回指针之后，为了安全着想，我们将不使用该指针。下面我将使用实例来说明不安全性。
[html] view plaincopy
  1. #include <stdio.h>  
  2.   
  3. int* f()  
  4. {  
  5.     int a[3] = {4, 5, 6};  
  6.     return a;  
  7. }  
  8.   
  9. int main()  
  10. {  
  11.     int *c = f();  
  12.     printf("%d, %d\n", c[0], c[1]);  
  13.     printf("%d, %d\n", c[0], c[1]);  
  14.     return true;  
  15. }  

这段程序的输出结果为：
4，5 
1245056， 4201335
很显然，在返回指针c后，直接输出c[0]c[1]，此时栈空间还么有被覆盖，所以可以正确的输出4,5。但是执行了第一个输出函数之后，可能覆盖了原来栈空间的内容，再进行输出的时候，就输出的是garbage value.因此这是不安全的。
(C) 是错误的，原因和B一样的
(D) 是错误的，原因有二，一是函数内申请的是栈空间。二是 ret是形参，所以当函数返回时，值不会发生变化。举个例子来说明：
[html] view plaincopy
  1. #include <stdio.h>  
  2.   
  3. void f(int *ret)  
  4. {  
  5.     int a[3] = {1, 2, 3};  
  6.     ret = a;  
  7.     return;  
  8. }  
  9.   
  10. int main()  
  11. {  
  12.     int *c = NULL;  
  13.     f(c);  
  14.     printf("%x\n", c);  
  15.     return true;  
  16. }  
结果是0，也就是说，c的值没有发生变化。

3、自己写的两个关于堆栈的例子？

为了说明上述选项D的原因，我自己写了一个程序来说明情况。
[html] view plaincopy
  1. #include <stdio.h>  
  2. #include <malloc.h>  
  3.   
  4. void Swap1(int a, int b)  
  5. {  
  6.     int temp;  
  7.     temp = a;  
  8.     a = b;  
  9.     b = temp;  
  10. }  
  11.   
  12. void Swap2(int* a, int* b)  
  13. {  
  14.     int temp;  
  15.     temp = *a;  
  16.     *a = *b;  
  17.     *b =*a;  
  18. }  
  19.   
  20. void RequestHeap1(int* array)  
  21. {  
  22.     printf("RequestHeap1 申请动态空间之前 %d\n", array);  
  23.     <span style="white-space:pre">  </span>array = (int *)malloc(sizeof(int) * 4);  
  24.     printf("RequestHeap1 申请动态空间之后 %d\n", array);  
  25. }  
  26.   
  27. void RequestHeap2(int** array)  
  28. {  
  29.     printf("RequestHeap2 申请动态空间之前 %d\n", *array);  
  30.     *array = (int *)malloc(sizeof(int) * 4);  
  31.     printf("RequestHeap2 申请动态空间之后 %d\n", *array);  
  32. }  
  33.   
  34. void DeleteHeap(int* array)  
  35. {  
  36.     if (array != NULL)  
  37.     {  
  38.         free(array);  
  39.         array = NULL;  
  40.     }  
  41.       
  42. }  
  43.   
  44.   
  45. int main()  
  46. {  
  47.     int tmp1 = 3, tmp2 =5;  
  48.     Swap1(tmp1, tmp2);  
  49.     printf("tmp1 = %d, tmp2 = %d\n", tmp1, tmp2);  
  50.       
  51.     Swap2(&tmp1, &tmp2);  
  52.     printf("tmp1 = %d, tmp2 = %d\n", tmp1, tmp2);  
  53.   
  54.     <span style="white-space:pre">  </span>int *array1 = NULL;  
  55.     <span style="white-space:pre">  </span>RequestHeap1(array1);  
  56.     printf("RequestHeap1 Return : %d\n", array1);   
  57.     DeleteHeap(array1);  
  58.   
  59.     int *array2 = NULL;  
  60.     RequestHeap2(&(array2));  
  61.     printf("RequestHeap2 Return : %d\n", array2);  
  62.     DeleteHeap(array2);  
  63.   
  64.     return true;  
  65. }  

程序运行结果如下：

在void Swap1(int a, int b)中， a 与 b 是形参，在函数内形参的值虽然发生改变，但是函数执行后，并不会改变实参的值。也就是在执行Swap1(tmp1, tmp2)时，将实参tmp1和tmp2的值赋予形参a和b，在函数内改变形参的值，但是并不会影响实参值，所以执行Swap1(tmp1, tmp2)之后，tmp1和tmp2的值并不发生变化。
void Swap2(int * a, int*  b)中，a 与 b是int *类型，也是形参，同样，函数执行后不会改变实参的值。也就是执行Swap2（&tmp1,&tmp2)时，将tmp1和tmp2的指针赋值给形参a和b，然而在这个函数中，我们是利用指针来改变该指针指向的值。即temp = *a; *a = *b; *b = temp;
同理，void Request1(int *array)，在执行RequestHeap1(array1)时，将array1赋值给形参array，在函数中对形参array进行各种操作之后，并不会直接改变实参的值。所以我们发现在执行该函数后，array1仍为0。
而void Request2(int** array)，再执行RequestHeap2(&(array2))时，将array2的地址赋值给形参array，在函数中对*array进行操作，实际它并没有改变&(array2)，但是该函数改变了*array2的值。
不知道大家明白了没？

4、如何动态申请二维数组

[html] view plaincopy
  1. #include <stdio.h>  
  2. #include <malloc.h>  
  3.   
  4. void RequestHeap2(int*** array, int m, int n)  
  5. {  
  6.     *array = (int**) malloc(sizeof(int *) * m);  
  7.     for (int i = 0; i < m; i++)  
  8.     {  
  9.         (*array)[i] = (int*)malloc(sizeof(int) * n);  
  10.     }  
  11. }  
  12.   
  13. int** RequestHeap1(int m, int n)  
  14. {  
  15.     int** array;  
  16.     array = (int**) malloc(sizeof(int *) * m);  
  17.     for (int i = 0; i < m; i++)  
  18.     {  
  19.         array[i] = (int*)malloc(sizeof(int) * n);  
  20.     }  
  21.     return array;  
  22. }  
  23.   
  24. void DeleteHeap(int** array, int m, int n)  
  25. {  
  26.     for (int i = 0; i < m; i++)  
  27.     {  
  28.         free(array[i]);  
  29.         array[i] = NULL;  
  30.     }  
  31.     free(array);  
  32.     array = NULL;  
  33. }  
  34.   
  35. void main()  
  36. {  
  37.     int** ppArray1 = NULL;  
  38.     int** ppArray2 = NULL;  
  39.     int m, n;  
  40.     scanf("%d, %d", &m, &n);  
  41.   
  42.     ppArray1 = RequestHeap1(m, n);  
  43.     ppArray1[0][0] = 5;  
  44.     printf("%d, %x\n", ppArray1[0][0], ppArray1);  
  45.     DeleteHeap(ppArray1, m, n);  
  46.   
  47.     RequestHeap2(&(ppArray2), m, n);  
  48.     ppArray2[0][0] = 5;  
  49.     printf("%d, %x\n", ppArray2[0][0], ppArray2);  
  50.     DeleteHeap(ppArray2, m, n);  
  51. }  


我们使用了两种方法，
（1） int** RequestHeap1(int m, int n)，在函数内部申请动态二维数组空间，并返回指针。
（2）void RequestHeap2(int*** array, int m, int n)， 通过参数int *** array传递一个二维数组的首地址的指针，来完成二维数组的创建
运行结果如下：

运行成功！

 

posted @ 2013-03-25 20:56  沙漏哟  阅读(1460)  评论(0)  编辑  收藏  举报