数组的动态内存分配

1.已知数组的第二维进行动态内存分配
方式：利用数组指针

#include <iostream>
using namespace std;

int main(int argc,char *argv[])
{
    const int N=5; //列数
    int m=4;  //行数
    int (*p)[N]=new int[m][N]; //创建数组指针并指向一个匿名数组
    //给每一个元素赋值
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<N;j++)
        {
            p[i][j]=i+j;
            cout<<i<<' '<<j<<' '<<p[i][j]<<endl;
        }
    }
    delete [] p;  //释放内存
    return 0;
}

2.1已知数组的第一维进行动态内存分配
方式：利用指针数组

#include <iostream>
using namespace std;

int main(int argc,char *argv[])
{
    const int M=5; //行数
    int n=4;  //列数
    int *p[M];    //创建指针数组
    //令指针数组的每一个元素指向一个一维数组
    for(int i=0;i<M;i++)
    {
        p[i]=new int[n];
    }
    //赋值
    for(int i=0;i<M;i++)
    {
        for(int j=0;j<n;j++)
        {
            *(p[i]+j)=i+j;
            cout<<i<<' '<<j<<' '<<*(p[i]+j)<<endl;
        }
    }
    //释放内存
    for(int i=0;i<M;i++)
    {
        delete [] p[i];
    }
    return 0;
}

2.2已知第一维一次性进行内存分配
方式：利用指针数组

#include <iostream>
using namespace std;

int main(int argc,char *argv[])
{
    const int M=5; //行数
    int n=4;  //列数
    int *p[M];  //指针数组
    p[0]=new int[M*n];  //首地址指向一个数组
    //连续分配内存
    for(int i=1;i<M;i++)
    {
        p[i]=p[i-1]+n;
    }
    //赋值
    for(int i=0;i<M;i++)
    {
        for(int j=0;j<n;j++)
        {
            *(*(p+i)+j)=i+j;
            cout<<i<<' '<<j<<' '<<*(*(p+i)+j)<<endl;
        }
    }
    //释放内存
    delete [] p[0];
    return 0;
}

3.1第一维第二维都未知动态分配内存
方式：双层指针，每一个元素指向一个指针数组

#include <iostream>
using namespace std;

int main(int argc,char *argv[])
{
    int m=4,n=5;  //行数和列数
    int **p;      //双层指针
    p=new int *[m];  // 指向一个指针数组
    //分配每一个指针所指向的数组
    for(int i=0;i<m;i++)
    {
        p[i]=new int[n];
    }
    //赋值
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            *(*(p+i)+j)=i+j;
            cout<<i<<' '<<j<<' '<<*(*(p+i)+j)<<endl;
        }
    }
    //释放内存
    for(int i=0;i<m;i++)
    {
        delete [] p[i];
    }
    delete [] p;
    return 0;
}

3.2两维都未知情况下一次性分配内存
方式：双层指针，指针数组，首地址指向数组内存

#include <iostream>
using namespace std;

int main(int argc,char *argv[])
{
    int m=4,n=5;
    int **p;      //双层指针
    p=new int*[m];    //指针数组
    p[0]=new int[m*n];  //首地址指向数组内存区
    for(int i = 1; i < m; ++i)
    {
    	p[i] = p[i-1] + n;
    }
    //赋值
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
        *(*(p+i)+j)=i+j;
        cout<<i<<' '<<j<<' '<<*(*(p+i)+j)<<endl;
        }
    }
    //释放内存
    delete [] p[0];
    delete [] p;
    return 0;
}

总结起来，只有第二维已知时，只需要一个指针（数组指针）就可以，这时直接令该数组指针（指向数组的指针）指向一个匿名的二维数组内存区（的首地址）；只有第一维已知时，则需要一个指针数组（存放指针的数组），令该指针数组每个元素指向数组的每一行；两维都未知时，需要创建一个双层指针，该指针指向一个指针数组，再令所指向的指针数组中每一个元素指向二维数组的每一行。如果要使指针数组中所有元素直接一次性指向数组内存区时，需要令该指针数组的首地址直接指向该二维数组内存区的首地址。可以这样做是因为二维数组的存储方式。