C++中创建二维数组

创建非动态二维数组的方法

数据类型 数组名[整常量表达式][ 整常量表达式]={ 初始化数据 }；

在{ }中给出各数组元素的初值，各初值之间用逗号分开。把{ }中的初值依次赋给各数组元素。
有如下几种初始化方式：

⑴ 分行进行初始化

int a[2][3]={{1,2,3},{4，5，6}};

在{ }内部再用{ }把各行分开，第一对{ }中的初值1，2，3是0行的3个元素的初值。第二对{ }中的初值4，5，6是1行的3个元素的初值。相当于执行如下语句：

int a[2][3]；
a[0][0]=1；a[0][1]=2；a[0][2]=3；a[1][0]=4；a[1][1]=5；a[1][2]=6；

注意，初始化的数据个数不能超过数组元素的个数，否则出错。

⑵ 不分行的初始化

int a[2][3]={ 1,2，3，4，5，6};

把{ }中的数据依次赋给a数组各元素（按行赋值）。即a[0][0]=1; a[0][1]=2；a[0][2]=3；a[1][0]=4；a[1][1]=5；a[1][2]=6；

⑶ 为部分数组元素初始化

static int a[2][3]={{1,2},{4}};

第一行只有2个初值，按顺序分别赋给a[0][0]和a[0][1]；第二行的初值4赋给a[1][0]。由于存储类型是static，故其它数组元素的初值为0。注：某些C语言系统（如：Turbo C）中，存储类型不是static的变量或数组的初值也是0。
static int a[2][3]={ 1,2};
只有2个初值，即a[0][0]=1，a[0][1]=2，其余数组元素的初值均为0。

⑷ 可以省略第一维的定义，但不能省略第二维的定义。系统根据初始化的数据个数和第2维的长度可以确定第一维的长度。

int a[ ][3]={ 1,2，3，4，5，6};

a数组的第一维的定义被省略，初始化数据共6个，第二维的长度为3，即每行3个数，所以a数组的第一维是2。
一般，省略第一维的定义时，第一维的大小按如下规则确定：
初值个数能被第二维整除，所得的商就是第一维的大小；若不能整除，则第一维的大小为商再加1。例如，int a[ ][3]={ 1,2，3，4};等价于：int a[2][3]={ 1,2，3，4};
若分行初始化，也可以省略第一维的定义。下列的数组定义中有两对{ }，已经表示a数组有两行。

static int a[ ][3]={undefined{1,2},{4}};

创建动态二维数组的方法

动态开辟二维数组，方法1：用new在堆上开辟；方法2：用vector开辟。

方法1：

//创建1
int **p=new int*[x];
for(int i=0;i<x;i++)
{
  p[i]=new int[y];
}          //定义二维数组x行y列  
//创建2
int **p=NULL;
p=new int*[row];
for(int i=0;i<row;++i)
{
	p[i]=new int[col];
}
//创建3
int len;
int**p = (int**)malloc(sizeof(int*) * len);
	for (int i = 0; i < len; ++i)
	{
		p[i] = (int*)malloc(sizeof(int) * 100);
	}

//二维数组的赋值        
for(int i=0;i<x;i++)
for(int j=0;j<y;j++)
{
  cin>>p[i][j];
}                  

 //销毁
for(int i=0;i<x;i++)
{
  delete[] p[i];
  p[i]=NULL;
}
delete []p;          //回收动态数组空间
p=NULL;

方法二：

  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;
        }
    }

编译时两次调用vector的构造函数对象test，第一次调用构造一个无名的含有col个0的vector对象.

第二次调用构造函数，以这个无名向量为初始值初始化它的row个元素！

静态数组（[]）和动态数组（new）的区别

本文以实例分析了C++语言中关于[]静态数组和new分配的动态数组的区别，可以帮助大家加深对C++语言数组的理解。具体区别如下：

1.对静态数组名进行sizeof运算时，结果是整个数组占用空间的大小；因此可以用sizeof(数组名)/sizeof(*数组名)来获取数组的长度。
int a[5]; 则sizeof(a)=20,sizeof(*a)=4.因为整个数组共占20字节，首个元素（int型）占4字节。
int *a=new int[4];则sizeof(a)=sizeof(*a)=4,因为地址位数为4字节，int型也占4字节。
2.静态数组作为函数参数时，在函数内对数组名进行sizeof运算，结果为4，因为此时数组名代表的指针即一个地址，占用4个字节的内存(因为在传递数组名的参数时，编译器对数组的长度不做检查，具体可参考前面一篇c++对数组的引用实例分析)。对动态数组的函数名，无论何时进行sizeof运算，得到的结果都是4。
3.new还需要你delete，是在堆分配空间，效率较低；而[]直接在栈上分配，会自动释放，效率高，但是栈空间有限。
4.通过函数返回一个数组的问题
函数声明的静态数组不可能通过函数返回，因为生存期的问题，函数调用完其内部变量占用的内存就被释放了。如果想通过函数返回一个数组，可以在函数中用new动态创建该数组，然后返回其首地址。
其原因可以这样理解，因为[]静态数组是在栈中申请的，而函数中的局部变量也是在栈中的，而new动态数组是在堆中的分配的，所以函数返回后，栈中的东西被自动释放，而堆中的东西如果没有delete不会自动释放。

例子如下：

//b可以是静态数组的数组名，也可以是动态数组的首地址
int *test(int *b) 
{
    //输出传入的数组各元素
    for(int i = 0; i < 5; ++i) {
        cout << *(b+i)<<" ";
    }
    cout << endl;
    //动态创建一个数组
    int *c = new int[5]; 
    //如果将绿色部分换为int c[5];则主函数中调用test无法得到c数组
    //新数组的各项值等于传入的数组各项值加5
    for(i = 0; i < 5; ++i) { 
        *(c+i) = *(b+i) + 5;
    }
    //返回新创建的动态数组的首地址
    return c;     
}
int main()
{   
    //创建动态数组b
    int *b = new int[5];
    //赋值
    for(int i = 0; i < 5; ++i) {
        *(b+i) = i; 
    }
    //绿色部分也可以换为int b[5]={0,1,2,3,4};即也可以是静态数组

    //将b作为参数，调用test函数，返回值赋给c
    int *c = test(b);   
    //输出test返回的数组的各项
    for(i = 0; i < 5; ++i) {
        cout << *(c+i) << " ";
    }
    cout<<endl;
    return 0;
}