动态分配内存 and malloc&new and 数组的动态分配、初始化（memset）和撤销(delete)

 在计算机的系统中有四个内存区域：
1）栈：在栈里面存储一些我们定义的局部变量和形参。
2）字符常量区：主要存储一些字符常量，比如：char *p_str="cat"，其中"cat"就存储于字符常量区里。
3）全局区：在全局区里储存一些全局变量和静态变量
4）堆：主要是通过动态分配的储存空间，即动态分配内存空间。
栈是线程相关的 一个线程会建立一个栈，函数中的局部变量 实际上是在栈里面的 函数返回后 就从栈中pop出来，栈的容量是有限的 超过一定大小就栈就会击穿了，比如你写了深层次的递归，然后再函数中使用大量的数组，很容易就击穿了
堆是动态存储空间，一个进程默认只有一个堆，进程中所有的线程都共享这个堆的空间，所以你在一个线程中从堆中分配内存，再另一个线程中也可以访问，同时堆也更容易扩展和交换数据
为什么要动态分配内存？
一是受栈空间的限制，二是不想浪费内存。
动态分配和静态分配的比较：
动态分配就是基于现实考虑，在需要时才分配你需要数量的内存（当然你申请的内存什么时候用完，只有你才知道，系统不会浪费时间给你猜的）。
一般的静态变量都是放在栈里（按顺序排列好，访问也最快，当然在回收前是不能改变顺序和已分配的数量的，作用域结束就回收），受栈的限制。
 
malloc 和  new
1）new 是c++中的操作符，malloc是c 中的一个函数
2）new 不止是分配内存，而且会调用类的构造函数，同理delete会调用类的析
构函数，而malloc则只分配内存，不会进行初始化类成员的工作，同样free也不
会调用析构函数
3）内存泄漏对于malloc或者new都可以检查出来的，区别在于new可以指明是那
个文件的那一行，而malloc没有这些信息
4）new 和 malloc效率比较
new 有三个字母, malloc有六个字母
new可以认为是malloc加构造函数的执行。
new出来的指针是直接带类型信息的。
而malloc返回的都是void指针
 
数组的动态分配(new)、初始化(memset)和撤销(delete)
一维数组：
malloc的例子：
int* pB2 = (int*)malloc(20 * sizeof(int));
if(pB2 == NULL) return 0;
memset(pB2,-1,20 * sizeof(CvBlob)); //初始化为-1
/**************/
if(pB2)
{
 free(pB2);
 pB2 = NULL;
}
new 的例子:
int* pB2 = new int[20];
/****************/
delete []pB2;
pB2 = NULL;
二维数组：
二维数组(n行m列)利用new来进行动态分配实际上相当于对n个m元数组进行动态
分配。
int **array;
array=new int *[10];
for(int i=0;i<10;i++)
         array[i]=new int [5];
上面的操作完成了一个10行5列的二维数组array[10][5]的动态分配，可以看到
我们先动态分配一个10单元的数组的指针的指针的首地址给**array，然后再对
其每个首地址进行遍历，同时完成一个5单元的数组的动态分配，并把首地址给
array[i]，从而完成了二维数组array[10][5]的动态分配。
   因为memset只能完成一个一维数组的初始化，因此最好的办法就是和二维数
组的动态分配结合起来，new一个，memset一个。
int **array;
array = new int[10];
for(int i=0;i<10;i++)
{
 array[i] = new int[5];
 memset(array,0,5*sizeof(int));
}
二维数组的撤销
for(int i=0;i<10;i++)
{
 delete []array[i];
}
delete []array;
三维数组用一个例子说明：
 
#include <stdio.h>
#include <memory.h>
#define size1 5
#define size2 10
#define size3 15
 
int main()
{
       int *** arr;
       int i,j,k;
       /////////////////// 动态开辟 相当于arr[size1][size2][size3]
       arr = new int**[size1];
       for (i = 0; i < size1; i ++) {
              arr[i] = new int*[size2];
              for (j = 0; j < size2; j ++) {
                     arr[i][j] = new int[size3];
              }
       }
       /////////////////// 用for循环初始化
       for (i = 0; i < size1; i ++) {
              for (j = 0; j < size2; j ++) {
                     for (k = 0; k < size3; k ++) {
                            arr[i][j][k] = i * j * k;
                     }
              }
       }
       for (i = 0; i < size1; i ++) {
              for (j = 0; j < size2; j ++) {
                     for (k = 0; k < size3; k ++) {
                            printf("i*j*k=%d*%d*%d=
%d/n",i,j,k,arr[i][j][k]);
                     }
              }
       }
       /////////////////// 用memset，如果是静态int arr[][][]的话，
直接memset(arr,0,sizeof(arr));数组初始化为0
 
       for (i = 0; i < size1; i ++) {
              for (j = 0; j < size2; j ++) {
                     memset(arr[i][j],-1,sizeof(int) * size3);
              }
       }
 
       for (i = 0; i < size1; i ++) {
              for (j = 0; j < size2; j ++) {
                     for (k = 0; k < size3; k ++) {
                            printf("i,j,k=%d,%d,%d=
%d/n",i,j,k,arr[i][j][k]);
                     }
              }
       }
 
       ///////////////////// 释放内存
       for (i = 0; i < size1; i ++) {
              for (j = 0; j < size2; j ++) {
                     delete[] arr[i][j];
              }
              delete[] arr[i];
       }
       delete[] arr;
       return 0;
}