所谓动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不象数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。

3 \* r3 U0 {0 J* f$ n

例如我们定义一个float型数组：float score[100]; 但是，在使用数组的时候，总有一个问题困扰着我们：数组应该有多大？

& `! x1 B. `1 B& G! V# J

在很多的情况下，你并不能确定要使用多大的数组，比如上例，你可能并不知道我们要定义的这个数组到底有多大，那么你就要把数组定义得足够大。这样，你的程序在运行时就申请了固定大小的你认为足够大的内存空间。即使你知道你想利用的空间大小，但是如果因为某种特殊原因空间利用的大小有增加或者减少，你又必须重新去修改程序，扩大数组的存储范围。

. V" U% n1 X* \8 R, q# Z

这种分配固定大小的内存分配方法称之为静态内存分配。但是这种内存分配的方法存在比较严重的缺陷，特别是处理某些问题时：在大多数情况下会浪费大量的内存空间，在少数情况下，当你定义的数组不够大时，可能引起下标越界错误，甚至导致严重后果。

! c! H: j7 z; w

我们用动态内存分配就可以解决上面的问题. 所谓动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不象数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。从以上动、静态内存分配比较可以知道动态内存分配相对于静态内存分配的特点：

, H7 D+ Y' y& ?+ M8 k) k$ W

      1、不需要预先分配存储空间；

      2、分配的空间可以根据程序的需要扩大或缩小。

      内存的静态分配和动态分配的区别主要是两个：

      一是时间不同。静态分配发生在程序编译和连接的时候。动态分配则发生在程序调入和执行的时候。
      二是空间不同。堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由函数alloca（）进行分配。不过栈的动态分配和堆不同，他的动态分配是由编译器进行释放，无需我们手工实现。          对于一个进程的内存空间而言，可以在逻辑上分成3个部份：代码区，静态数据区和动态数据区。动态数据区一般就是“堆栈”。“栈(stack)”和“堆(heap)”是两种不同的动态数据区，栈是一种线性结构，堆是一种链式结构。进程的每个线程都有私有的“栈”，所以每个线程虽然代码一样，但本地变量的数据都是互不干扰。一个堆栈可以通过“基地址”和“栈顶”地址来描述。全局变量和静态变量分配在静态数据区，本地变量分配在动态数据区，即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。      一般，用static修饰的变量，全局变量位于静态数据区。函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。

5 g5 ]* r- P% m/ \. X& \

1、一维数组动态分配（1）

1. 
   
2. #include <iostream>
   8 X% m% O$ |2 }) a' H9 A- Q
3. 
   
4. //一维数组
   * j5 v' L# u, ?7 H+ r5 }
5. void oneDimensionalArray()
   
6. {
   ! M' {0 [# V& E4 ]% N
7.     //定义一个长度为10的数组
   
8.   int* array = new int[10];
   
9.     //赋值
   
10.   for(int i = 0; i < 10; i++)
    
11. {
    
12.        array[i] = i*2;
    ( o( j! P5 K8 C. ^9 [
13. }
    ) ^8 G  f2 o3 d7 l
14.   //打印
    
15.   for(int i = 0; i < 10; i++)
    
16. {
    
17.       std::cout << i << " : " << array[i] << std::endl;
      C# b1 s2 K# T9 }
18. }
    $ `& |$ n* U, S# [9 M0 r
19.     //释放内存
    
20.    delete[] array;
    
21. }

复制代码

注意：
% o2 L1 x% V# q7 B& m8 G/ R* q; l( J

int   *p=new   int[len];这一句，你不能这样做：int   p[len];

C++编译器会报错说len的大小不能确定，因为用这种形式声明数组，数组的大小需要在编译时确定。而且这样也不行：

int   p[]=new   int[len];

编译器会说不能把int*型转化为int[]型，因为用new开辟了一段内存空间后会返回这段内存的首地址，所以要把这个地址赋给一个指针，所以要用int   *p=new   int[len];

注意要注销指针p，使程序释放用new开辟的内存空间。

一维数组动态分配（2）

假设动态构造一个Int型数组：

1. 
   
2. 1 int *p = (int *)malloc(int len);
   4 s+ ], X& w6 r5 A" \
3. 2 //还可以写作：
   ; f( o3 d0 t5 X1 @' L( F
4. 3 int *p = (int *)malloc(sizeof(int)*len);
   * E$ l2 L" z& E. F6 [# r( O. h
5. 4 int *p = (int *)malloc(sizeof(len));
   6 S/ \2 m) @3 S( K
6. 5 数据类型 *p = (数据类型 *)malloc(sizeof(数据类型)*长度);

复制代码

      1.malloc只有一个int型的形参，表示要求系统分配的字节数

　　2.malloc函数的功能是请求系统分配len个字节的内存空间，如果请求成功，则返回第一个字节的地址，如果请求失败，则返回NULL。

　　3.malloc函数能且只能返回第一个字节的地址，所以我们需要把这个无任何实际意义的第一个字节的地址（俗称干地址）转化成一个有实际意义的地址，nalloc函数前面必须加（数据类型 *），表示把这个无实际意义的第一个地址转化为相应类型的地址。如：

1. 
   
2. #include <stdio.h>
   ) d3 A+ F8 k" H6 t$ y' t
3. #include <stdlib.h>
   . Z% l; Q9 L" R& r. V; o
4. int main()
   2 x* G9 t0 q! t' E# [& q
5. {
   
6. int n1,i;
   
7. int *array;
   1 C: {# h7 ^4 ^. [0 Z6 g
8. printf("请输入所要创建的一维动态数组的长度：");
   
9. scanf("%d",&n1);
   : M7 n* X  Z) E, }
10. array=(int*)calloc(n1,sizeof(int));
    9 [! Q  O: p, H2 s& |
11. for(i=0;i<n1;i++)
    
12. {
    
13.   printf("%d\t",array[i]);
    0 _& i/ x: I/ e# E( A- }$ L
14. }
    % ~, U3 s9 D& ?, C0 I
15. printf("\n");
    
16. for(i=0;i<n1;i++)
    
17. {
    * s; M5 k2 t" o
18.   array[i]=i+1;
    & |9 E( {# U# s- {) M4 p. \/ g3 o5 ]
19.   printf("%d\t",array[i]);
    
20. }
    ; k+ z+ Q4 g2 P2 U0 Z, O1 J
21.   free(array);//释放第一维指针
    
22.   return 0;
    $ y& E' d4 F+ U: c, w
23. }

复制代码

2、二维数组动态创建

在创建动态数组的过程中我们要遵循一个原则，那就是在创建的时候从外层往里层，逐层创建；而释放的时候从里层往外层，逐层释放。

array=(int**)malloc(n1*sizeof(int*)); //第一维

& C2 q' E; T2 v! l' S

以上是我们创建二维动态数组的最外层，创建好了最外层那么我们接下来就是要创建次外层了。这里使用了二级指针。

6 |2 K+ z- \$ m# z' F* s5 U

array=(int*)malloc(n2* sizeof(int));//第二维

在创建次外层的过程中我们使用了一个for语句，千万别忘了使用for循环语句，这是绝大多数人的一个易错点。

: B( G6 @. K6 i' y3 [9 I6 `$ Z; f

创建好了接下来我们该讲到释放了，而释放的时候从里层往外层，逐层释放。刚刚与我们上面的创建相反，在以上代码中我们首先使用了下面一个for循环来释放里层。

1. 
   
2. for(i=0;i<n1;i++)
   
3. {
   2 F0 y5 F: f# V3 w
4. free(array[i]);//释放第二维指针
   
5. }

复制代码

在通过以下语句来释放外层。
# Z; O6 q/ V* O) y+ Q: n

free(array);//释放第一维指针

1. 
     @7 ]' p9 f  q/ Q
2. #include <iostream>
   9 W2 S) {$ v4 w$ f0 Q1 r; e
3. #include <stdlib.h>
   
4. using namespace std;
   8 B1 ]& J- a) e7 G% h5 S7 f$ N
5. 
   " y2 Q7 ?4 Y( Y6 E2 V
6. int main(){
   . E4 G- n/ g/ S
7.   int num1,num2;
   + @" _( n- e# c: C
8.   cout<<"请输入动态二维数组的第一个维度：";
   . g0 q+ X% i& [. R/ i
9.   cin>>num1;
   
10.   cout<<"请输入动态二维数组的第二个维度：";
    : V5 O* J, F, N$ v% A1 m9 C& M
11.   cin>>num2;
    1 X- b2 T6 x% b: c, [( F
12.   int **array = (int **)calloc(num1,sizeof(int));
    # ]0 M- Y2 l; h1 x/ _
13.   for(int i=0;i<num1;i++) {
    ( s; I/ y5 ?6 f+ T
14.     array[i] = (int*)calloc(num2,sizeof(int));
    
15.   }
    . e, [& d) {$ p) k2 ?+ }
16.   for(int i=0;i<num1;i++){
    9 j, C2 U" [% a6 X" K( Z5 o
17.     for(int j=0;j<num2;j++){
    
18.       array[i][j] =i*num2+j+1;
    
19.       printf("%d\t",array[i][j]);
    8 l8 U8 f* n( h
20.     }
    
21.     cout<<endl;
    
22.   }
    3 M& @' @7 z  e8 R. U8 k( s5 j
23.   for(int i=0;i<num1;i++)  free(array[i]);
    
24.   free(array);
    
25.   return 0;
    
26. }

复制代码

  p3 ]# ?  t' Q7 c

3、三维数组动态创建

1. 
   / n4 {5 U( ]$ r4 n7 K
2. #include <stdlib.h>
   5 O8 [- Q( t9 B# t
3. #include <stdio.h>
   
4. int main()
   
5. {
   
6. int n1,n2,n3;
   
7. int ***array;
   
8. int i,j,k;
   
9. printf("请输入所要创建的动态数组的第一维长度：");
   
10. scanf("%d",&n1);
    5 g6 q8 t3 Z& Q( B6 i1 T; n
11. printf("请输入所要创建的动态数组的第二维长度：");
    % f' W# M1 z5 i6 N- F5 ~& l: P$ u2 K# h. E
12. scanf("%d",&n2);
    
13. printf("请输入所要创建的动态数组的第三维长度：");
    
14. scanf("%d",&n3);
    
15. array=(int***)malloc(n1*sizeof(int**));//第一维
    5 y" v  r7 D/ z: k# e
16. for(i=0; i<n1; i++)
    0 d5 W; ~! J/ d' \, p: r" U- R
17. {
      O2 D# Y) I: Y/ [3 h# {5 Q) K, B6 A3 a
18.   array[i]=(int**)malloc(n2*sizeof(int*)); //第二维
    ' X! `' s" c) f; Y/ E' Q
19.   for(j=0;j<n2;j++)
    # \8 d2 ^+ @, Y& W' V5 r. K3 I
20.   {
    - H, ]+ w2 y. a, s1 R4 c) t
21.     array[i][j]=(int*)malloc(n3*sizeof(int)); //第三维
    ) u( F0 N! a! h* e' D: d" V. K9 E
22.    }
    
23. }
    
24. for(i=0;i<n1;i++)
    
25. {
    0 P. F' K& G) R' V7 }
26.    for(j=0;j<n2;j++)
    7 P- D- I( ^% w- j1 H1 I
27.    {
    " E% t: ?/ z( D! l" U$ W
28.       for(k=0;k<n3;k++)
    
29.       {
    
30.         array[i][j][k]=i+j+k+1;
    + G  O1 k! j0 O9 {
31.         printf("%d\t",array[i][j][k]);
    % c+ h3 W& n$ b3 A  D
32.        }
    * ~7 V% o! B  b. _4 c4 D7 g
33.       printf("\n");
      l/ S8 b6 W- W! d1 W% f
34.     }
    
35.    printf("\n");
    
36. }
    
37. for(i=0;i<n1;i++)
    
38. {
    
39.    for(j=0;j<n2;j++)
    ) W+ Y( y# i! w
40.    {
    
41.      free(array[i][j]);//释放第三维指针
    $ ~) d! ?* d/ k! z8 h' T/ `, ]
42.    }
    
43. }
    
44. for(i=0;i<n1;i++)
    . [; l: \0 a* z0 c8 g
45. {
    2 V1 G: x3 K) q0 j" {; b8 o
46.     free(array[i]);//释放第二维指针
    / G0 [' X. W. h) A& w' `
47. }
    6 \: P( w) [! C: S0 G  l# \
48.   free(array);//释放第一维指针
    # g0 p3 D7 l) a2 A! b& V1 A# R
49.   return 0;
    
50. }

复制代码

4、动态数组创建后，不满足需求，继续扩大或缩小数组
0 q$ G8 X% o! n- Z& I1 L- F1 V9 l

4.1缩小动态数组

1. 
   ; _+ y2 s. f0 v1 w
2. #include <stdio.h>
   * c0 b9 V( G5 b3 Q, L5 s+ [
3. #include <stdlib.h>
   
4. int main()
   & G* P7 a8 G: W
5. {
   
6. int*n,*p;
   
7. int i,n1,n2;
   # l& g) D1 e) r' r) c9 Z0 r
8. printf("请输入所要创建的动态数组的长度：");
   
9. scanf("%d",&n1);
   
10. n=(int*)calloc(n1,sizeof(int));
    ! A6 v/ b0 z( [$ ]9 S" d
11. for(i=0;i<n1;i++)
    . P3 X% |9 m% f% j9 O
12. {
    3 W. c7 k, j6 \( O3 v( V$ Z1 [
13. n[i]=i+1;
    9 e! L7 i* Q. B7 b
14. if(i%5==0)
    1 b& |  w8 R# w: @/ ^" {* F: H% s
15. printf("\n");
    # R: Q+ j* ]1 X4 x5 p1 n/ X
16. printf("%d\t",n[i]);
    ( T) i8 c* r3 g  u1 A3 P- \
17. }
    & _' i5 y- l, B4 `% B" W
18. printf("\n请输入所要缩小的动态数组的长度：");
    
19. scanf("%d",&n2);
    
20. p=(int*)realloc(n,(n2)*sizeof(int));
    2 N0 C+ }8 e7 `) b/ @4 P& V$ ^3 A
21. for(i=0;i<n2;i++)
    ) E& Z& o. n7 s/ v
22. {
      d+ p, x1 o+ O
23. if(i%5==0)
    , F9 Q+ ]: g$ N: F6 I% C/ f
24. printf("\n");
    8 @2 I: M  s, `' U; M7 Y
25. printf("%d\t",p[i]);
    3 J8 O4 h' d: `/ R% m9 w
26. }
    
27. printf("\n");
    0 d1 J* v) A) \- P
28. free(p);
    
29. return 0;
    
30. }

复制代码

4.2扩大动态数组

1. 
   
2. #include <stdio.h>
   ' T( d, }" m/ |& n4 Q
3. #include <stdlib.h>
   
4. int main()
   
5. {
   ; V# B; R- p" B5 P: }6 j5 j
6. int*n,*p;
   9 B5 \, [0 R% Z& D' T! P/ \
7. int i,n1,n2;
   
8. printf("请输入所要创建的动态数组的长度：");
   
9. scanf("%d",&n1);
   . I) ^" T1 h7 g3 r* I  A/ M. ?
10. n=(int*)calloc(n1,sizeof(int));
    % h9 v. K9 L2 ^8 W. `5 S
11. printf("请输入所要扩展的动态数组的长度：");
    
12. scanf("%d",&n2);
    * Y) _& B6 ^8 r) n: m8 `
13. p=(int*)realloc(n,(n2)*sizeof(int));//动态扩充数组
    
14. for(i=0;i<n2;i++)
    5 q2 S/ T4 D! I$ v7 _* o& a- G
15. {
    
16. p[i]=i+1;
    
17. if(i%5==0)
    
18. printf("\n");
    
19. printf("%d\t",p[i]);
    
20. }
    
21. free(p);
    
22. return 0;
    
23. }

复制代码