new/delete多维数组/malloc分配动态二维数组

　new用法：

　　1．开辟单变量地址空间

　　1）new int； //开辟一个存放数组的存储空间，返回一个指向该存储空间的地址．int *a ＝ new int 即为将一个int类型的地址赋             值给整型指针a．

　　2）int *a ＝ new int（5）作用同上，但是同时将整数赋值为5

　　2．开辟数组空间

　　一维： int *a ＝ new int[100]；开辟一个大小为100的整型数组空间

　　

　　一般用法： new 类型 [初值]

　　C＋＋ delete用法：

　　1． int *a ＝ new int；

　　delete a； //释放单个int的空间

　　2．int *a ＝ new int[5]；

　　delete [] a； //释放int数组空间

　　要访问new所开辟的结构体空间，无法直接通过变量名进行，只能通过赋值的指针进行访问．

　　用new和C＋＋ delete可以动态开辟，撤销地址空间．在编程序时，若用完一个变量（一般是暂时存储的数组），下次需要再用，但却又想省去重新初始化的功夫，可以在每次开始使用时开辟一个空间，在用完后撤销它．

    int **a = new int[5][6]，这个根本编译不过去吧。
如果你想new一个二维数组出来，应该这样：

下面看一下二维的
int** a= new int*[5];
for (int i = 0; i < 5; ++i)
{
    a[i] = new int[6];
}
delete的时候，反过来就行了：
for (int i = 0; i < 5; ++i)

{
       delete[] a[i];
}
delete[] a;
三维数组，与此相同，举例如下：
int*** a= new int**[5];
for (int i = 0; i < 5; ++i)
{
     a[i] = new int*[6];
     for (int j = 0; j < 6; ++j)
    {
            a[i][j] = new int[7];
     }
}
for (int i = 0; i < 5; ++i)
{
     for (int j = 0; j < 6; ++j)
     {
           delete[] a[i][j];
     }
     delete[] a[i];
}
delete[] a;

vector法

#include <iostream>
#include <vector>
#include <iomanip>
using namespace std;

void main()
{
    int row, col;
    cout<<"请输入行列值:";
    cin>>row
        >>col;

    vector<vector<int> > test(row, vector<int>(col)); //声明一个二维数组，注意这里的空格不能少 

    //初始化，其实不初始化也是可以的，vector默认是0
    for (int i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
        {
            test[i][j] = 0;
        }
    }
    cout<<endl;
    //输出值
    for (i = 0; i < row; i++)
    {
        for (int j = 0; j < col; j++)
        {
            cout<<setw(5)<<test[i][j];
        }
        cout<<endl;
    }
    //输出行列值
    cout<<"行:"<<test.size()<<endl;
    cout<<"列:"<<test[1].size()<<endl;
}

malloc分配二维数组

1. 动态数组的成员都可以用正常的数组下标 Array[i][j]

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. void main()  
4. {  
5.      int nrows,ncolumns;  
6.      int **Array;  
7.      int i,j;  
8.      printf("please input nrows&ncolumns:/n");  
9.      scanf("%d%d",&nrows,&ncolumns);  
10.      Array=(int **)malloc(nrows*sizeof(int *));  
11.      for(i=0;i<nrows;i++)  
12.          Array[i]=(int *)malloc(ncolumns*sizeof(int));  
13.      for(i=0;i<nrows;i++)  
14.      {  
15.          for(j=0;j<ncolumns;j++)  
16.          {  
17.              Array[i][j]=1;  
18.              printf("%d ",Array[i][j]);   //动态数组的成员都可以用正常的数组下标 Array[i][j]  
19.          }  
20.          printf("/n");  
21.      }  
22.      free(Array);  
23. }  

2. 让数组的内容连续, 但在后来重新分配列的时候会比较困难, 得使用一点指针算术:

 

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. void main()  
4. {  
5.      int nrows,ncolumns;  
6.      int **Array;  
7.      int i,j;  
8.      printf("please input nrows&ncolumns:/n");  
9.      scanf("%d%d",&nrows,&ncolumns);  
10.      Array=(int **)malloc(nrows*sizeof(int *));  
11.      Array[0]=(int *)malloc(nrows*ncolumns*sizeof(int));  
12.      for(i=1;i<nrows;i++)  
13.          Array[i]=Array[0]+i*ncolumns;  
14.      for(i=0;i<nrows;i++)  
15.      {  
16.          for(j=0;j<ncolumns;j++)  
17.          {  
18.              Array[i][j]=1;  
19.              printf("%d ",Array[i][j]);   //动态数组的成员都可以用正常的数组下标 arrayx[i][j]  
20.          }  
21.          printf("/n");  
22.      }  
23.      free(Array);  
24. }  

3. 同一个单独的动态分配的一维数组来模拟二维数组:

 

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. void main()  
4. {  
5.      int nrows,ncolumns;  
6.      int *Array;  
7.      int i,j;  
8.      printf("please input nrows&ncolumns:/n");  
9.      scanf("%d%d",&nrows,&ncolumns);  
10.      Array=(int *)malloc(nrows*ncolumns*sizeof(int *));  
11.      for(i=0;i<nrows;i++)  
12.      {  
13.          for(j=0;j<ncolumns;j++)  
14.          {  
15.              Array[i*nrows+j]=1;  
16.              printf("%d ",Array[i*nrows+j]);   //用 array3[i * ncolumns + j] 访问第 i, j 个成员  
17.          }  
18.          printf("/n");  
19.      }  
20.      free(Array);  
21. }