二维数组的引用和初始化

二维数组的引用
    与一维数组一样，多维数组一般也不能整体操作，整体操作需转化成对数组的分量下标变量进行。
    下标变量的形式为：数组名[下标表达式1][下标表达式2]
    多维数组下标变量的形式为：数组名[下标表达式1][下标表达式2]…
    [下标表达式n]
    例如，对以上定义的acj数组3000个分量分别为：acj[0][O]、acj[1 O][1]、…、acj[O]
[29]、acj[1][O]、acj[1][1]、…、acj[1][29]、…、acj[999][0]、acj[999][1]、…、acj[999]
[29]，左边下标变化最慢，右边下标变化最快，右边下标变化一遍，左边下标才变化一次。
每个分量对应一个学生一门课程的成绩，acj—Li][j]相当于一个float型变量。
    说明：
    (1)每个下标的取值范围从。到数组长度减1，下标变量同样相当于基类型变量，中国自学编程网首发。
    (2)对于多维数组整体操作的完成需用多重循环，一个下标对应于一重循环控制变量。二维数组的整体操作用两重循环完成，外重循环对应下标1，内重循环对应下标2。
    (3)其它类似于一维数组处理。

二维数组的初始化
    二维数组及多维数组的初始化和一维数组类似，只有静态存储数组和外部存储数组，才能在编译阶段初始化。
  初始化形式：
  存储类别类型数组名[下标1][下标2]={常量l，常量2，…，常量n)；
  例如：
  static int a[3][4]={1，2，3，4，5，6，7，8，9，10，11，12}；
  a[O][O]=1，aEO][1]=2，a[O][2]=3，a[O][3]=4，
  a[1][O]=5，a[1][1]=6，a[1][2]=7，a[1][3]=8，
  a[2][O]=9，a[2][1]=10，a[2][2]=11，a[2][3]=12

    (1)二维数组的初始化可以分行进行。例如，上面的a数组初始化还可以表示为：
    static int a[3][4]={{1，2，3，4)，{5，6，7，8)，{9，10，11，12))；
    而定义4行3列的b数组可以表示为：
    static int b[4][3]={{1，2，3)，{4，5，6}，{7，8，9}，{10，11，12})；
    可以只对数组中部分元素初始化。例如：
  a[0][o]=1，a[o][1]=2，a[1][o]=5，a[2][o]=9，其它分量初值取默认值，为o。
  (3)如果对二维数组中全部元素初始化，则定义数组时第一维的长度可以省略，但第二维的长度不能省略。例如：
    static int a[3][4]={1，2，3，4，5，6，7，8，9，10，11，12)；
可以写成
    static int a[][4]={1，2，3，4，5，6，7，8，9，10，11，12}；
但不能写成
    static int a[][]={1，2，3，4，5，6，7，8，9，10，11，12)；
因为两个维数都省略时，可以理解为1*12、12*1、3*4、4*3、2*6、6*2等多种形式，会发生混淆，故只能省略第一个维数。
    (4)如果对二维数组按行进行初始化，则定义数组时第一维的长度也可以省略。例如：
    static int a[][4]={{1，2}，{5}，{9})；[Page]
    对于二维数组与多维数组作函数参数跟一维数组作函数参数类同处理，但对形参数组，只有第一维的大小可以省略，第二维及其它高维的大小均不能省略。
   

 

C++二维数组new小结(zz)

 

1.
A (*ga)[n] = new A[m][n];
...
delete []ga;
缺点：n必须是已知
优点：调用直观，连续储存，程序简洁(经过测试，析构函数能正确调用)

2. A** ga = new A*[m];
for(int i = 0; i < m; i++)
ga[i] = new A[n];
...
for(int i = 0; i < m; i++)
delete []ga[i];
delete []ga;
缺点：非连续储存，程序烦琐，ga为A**类型
优点：调用直观，n可以不是已知

3. A* ga = new A[m*n];
...
delete []ga;
缺点：调用不够直观
优点：连续储存，n可以不是已知

4. vector > ga;
ga.resize(m); //这三行可用可不用
for(int i = 1; i < n; i++) //
ga[i].resize(n); //
...

缺点：非连续储存，调试不够方便，编译速度下降，程序膨胀(实际速度差别不大)
优点：调用直观，自动析构与释放内存，可以调用stl相关函数，动态增长

5. vector ga;
ga.resize(m*n);
方法3,4的结合


6. 2的改进版
A** ga = new A*[m];
ga[0] = new A[m*n];
for(int i = 1; i < m; i++)
ga[i] = ga[i-1]+n;
优点:连续存储,n可以不是已知,析构方便,猜想只需delete [] ga;

 

问题:

1.怎么进行多维数组的声明和初始化?

2.是否能够动态分配多维数组,怎么样正确析构?

3.怎么理解这些操作?

抛出问题,本周搞定.