为编写将二维数组作为参数的函数，必须牢记，数组名被视为地址，因此相应的形参是一个指针，比较难处理的是如何正确声明指针。

在被调用函数中对形参数组定义时可以可以指定所有维数的大小，也可以省略第一维的大小说明。如：

void Func(int array[3][10]);
void Func(int array[][10]);


二者都是合法而且等价，但是不能把第二维或者更高维的大小省略，如下面的定义是不合法的： 

    void Func(int array[][]);

将二维数组当作参数的时候，必须指明所有维数大小或者省略第一维的，但是不能省略第二维或者更高维的大小，这是由编译器原理限制的。编译器是这样处理数组的：对于数组 int p[m][n]; 


  
如果要取p[i][j]的值(i>=0 && i< m && 0<=j && j < n)，编译器是这样寻址的，它的地址为：   p + i*n + j;


从以上可以看出，如果我们省略了第二维或者更高维的大小，编译器将不知道如何正确的寻址。

下面我们提供三种方式对二维数组进行传参：

一、在声明的时候，给入第二维维数大小

void printArray(int (*arr)[9], int w, int h) {
    for (int i = 0; i < h; i++) {
        for (int j = 0; j < w; j++) {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }
}

二、在声明的时候，用一维指针去指向二维数组， 模拟编译器寻址

由一知道，如果要把这个数组进行封装，是不适用的，因为你直接函数中



写死了二维数组的第二维维数大小
void printArray2(int * arr, int w, int h) {

    for (int i = 0; i < h; i++) {
        for (int j = 0; j < w; j++) {
            cout << arr[i*w+j] << " ";
        }
        cout << endl;
    }

}

三、建立一个指针数组，进行指向原二维数组，同时在函数中传入二维指针



void printArray3(int ** arr, int w, int h) {

    for (int i = 0; i < h; i++) {
        for (int j = 0; j < w; j++) {
            cout << arr[i][j] << " ";
        }
        cout << endl;
    }

}

测试：



int main(void) {

    int arr[][9] = { { 0,0,0,0,0,0,0,0,0 },
                    { 0,1,1,0,1,1,1,1,0 },
                    { 0,1,1,1,1,0,0,1,0 },
                    { 0,1,1,0,1,0,0,0,0 },
                    { 0,0,0,0,1,1,1,0,0 },
                    { 0,0,0,0,1,1,1,0,0 },
                    { 0,0,0,0,0,0,0,0,0 } };

    cout << "=============== method 1 ===============" << endl;
    printArray(arr, 9 ,7);

    cout << "=============== method 2 ===============" << endl;
    printArray2(*arr, 9, 7);

    cout << "=============== method 3 ===============" << endl; 
    int *p[7]; // define array of pointers (指针数组)
    for (int i = 0; i < 7; i++)
        p[i] = arr[i];
    printArray3(p, 9, 7);

    system("pause");
    return 0;
}

题目：

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

 

思路：

对输入的条件进行判断，没有正确输入的话做出提示。

矩阵是有序的，从右上角开始看起
	
如果目标数大于当前数，说明目标数在当前数下方，行数++；
	
如果目标数小于当前数，说明目标数在当前数的左侧，列数--；
	
这样每一次查找都可以排除一行或者一列。
 

代码：

public class Main {

    public static void Find(int target, int [][] array) {
        //输入条件判断
        if( array == null || array.length < 1 || array[0].length < 1) {
            System.out.println("请输入正确条件");
        }

        int rows = array.length;        //数组行数
        int columns = array[0].length;  //数组列数
        int row = 0,coulmn = columns - 1;

        System.out.println(rows);
        while (row < rows && coulmn >= 0){
            if (array[row][coulmn] == target) {     //与查找的数相等
                System.out.println("该数在第" + row +"行第" + coulmn + "列");
                break;
            }else if (target > array[row][coulmn]) {    //目标数大于当前数组的数，说明目标数在下方，行数++
                row ++;
            }else {
                coulmn --;                              //目标数小于当前数组的数，说明目标数在左方，列数--
            }
        }
    }

    public static void main(String[] args) {    //测试
        int[][] arr = {
                {1, 2, 8, 9},
                {2, 4, 9, 12},
                {4, 7, 10, 13},
                {6, 8, 11, 15}
        };

        Find(7,arr);
    }
}



 

正确写法：

void Func(int array[3][10]);
void Func(int array[][10]);

错误写法：

void Func(int array[][]);
void Func(int array[3][]);

用二维数组名作为实参或者形参，在被调用函数中对形参数组定义时可以指定所有维数的大小，也可以省略第一维的大小说明。
	
二者都是合法而且等价，但是不能把第二维或者更高维的大小省略。
	
对于数组 
                                    int p[m][n];

        如果要取p[i][j]的值(i>=0 && i<m && 0<=j && j < n)，编译器是这样寻址的，它的地址为：p + i*n + j;

1. 引用数组元素时， 其数组下标的数据类型允许是 整型常量或整型表达式

2. 一维数组的定义方式为： 类型说明符 数组名 [整型常量表达式]    

3. 以下能对二维数组a 进行正确初始化的语句是：

   A） int a[2][]={{1,0,1},{5,2,3}};

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

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

   D） int a[][3]={{1,0,1},{},{1,1}};

答案：B；A选项列标不可省略；C选项超出了范围；D选项赋初值不可有{}

4. 以下不能对二维数组a 进行正确初始化的语句是

A） int a[2][3]={0};

B） int a[][3]={{1,2},{0}};

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

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

答案：C；超出了范围

5. 若有说明：int a[3][4]; 则全局数组a 中各元素         

A） 可在程序的运行阶段得到初值0

B） 可在程序的编译阶段得到初值0

C） 不能得到确定的初值

D） 可在程序的编译或运行阶段得到初值0

 答案：B

6. 下面程序如果只有一个错误， 那么是（每行程序前面的数字表示行号）         

1 main()
2 { 
3     float a[3]={3*0}; 
4     int i; 
5     for(i=0;i<3;i++) scanf(“%d”,&a[i]); 
6         for(i=1;i<3;i++) a[0]=a[0]+a[i]; 
7     printf(“%d\n”,a[0]); 
8 }

答案：第3行；

7. 若二维数组a 有m 列，则计算任一元素a[i][j]在数组中位置的公 式为 （假设a[0][0]位于数组的第一个位置上。）

A）i*m+j        

B）j*m+i        

C）i*m+j-1        

D）i*m+j+1

答案：D

8.  以下对一维数组的定义中不正确的是（    ）

A. double x[5]={2.0,4.0,6.0,8.0,10.0};   

B. int  y[5]={0,1,3,5,7,9};

C. char ch1[ ]={'1', '2', '3', '4', '5'};     

D. char  ch2[ ]={'\x10', '\xa', '\x8'};

答案：解析：可以对一维数组的全部元素或部分元素赋初值。在对全部数组元素初始化时，数组长度可以省略。若数组长度没有省略，则初始化列表中值的个数不能超过数组的长度。

答案：B

9. 以下对二维数组的定义中正确的是（    ）。

A．int a[4][]={1，2，3，4，5，6};    B. int  a[][3];

C．int a[][3]= {1，2，3，4，5，6};   D. int a[][]＝{{1,2,3},{4,5,6}};

解析：定义二维数组时，若按一维格式初始化，则第一维的长度可以省略，此时，系统可根据初始化列表中值的个数及第二维的长度计算出省略的第一维长度，但无论如何，第二维的长度不能省略。没有初始化时，每一维的长度都不能省略。

答案：C

10. 若有定义：int aa[8];，则不能代表数组元素aa[1]地址的是（   ） 。

A. &aa[0]+1     B. &aa[1]      C. &aa[0]++      D. aa+1

解析： &aa[1]、&aa[0]+1和aa+1都是数组元素aa[1]的地址。由于&aa[0]是地址值常量，不能进行自加、自减运算，所以选项C不能代表aa[1]地址。

答案：C

11. 若有如下定义，则b的值是（    ）。

int a[10]={1,2,3,4,5,6,7,8,9,10},*p=&a[3],b=p[5];

A. 5                   B. 6                C. 8             D. 9

解析：p指向a[3]，即p=a+3；b=p[5]，即b=*(p+5)。因此，b=*(a+8)=a[8]=9。

答案：D

12. 若二维数组y有m列，则排在y[i][j]前的元素个数为（    ）

A.j*m+i　　　　B.i*m+j       C.i*m+j-1　　　 D.i*m+j+1

解析：C语言中的二维数组按行存储。行标为i的元素前共有i行元素，元素个数为i*m，每行列标为j的元素前共有j个元素。因此，y[i][j]前的元素个数为i*m+j。

答案：B

13. 若有定义：char a[10],*b=a;，则不能给数组a输入字符串”This is a book”的语句是(    )。

A. gets(a)      B. scanf("%s",a)     C. gets(&a[0]);    D. gets(b) ;

解析： gets为字符串输入函数，调用该函数时需给出字符串的存储地址，以回车作为字符串输入的结束，并将回车符转换成为’\0’。而scanf函数则以回车、空格或跳格作为串输入结束，因此scanf不能输入有空格的字符串。

答案：B

14. 有以下程序, 执行后输出结果是(     )

main() 

{ int x[8]={8,7,6,5,0},*s; 

  s=x+3; 

  printf("%d ",s[2]);

} 

A. 随机值           B. 0           C. 5            D. 6

答案：B

15. 下列描述中不正确的是 (     )。

 

A. 字符型数组中可以存放字符串              

B. 可以对字符型串进行整体输入、输出

C. 可以对整型数组进行整体输入、输出         

D. 不能在赋值语句中通过赋值运算符"="对字符型数组进行整体赋值

答案：C；C语言规定只能逐个引用数组元素而不合下次引用整个数组。字符数组的输入、输出可以将整个字符串一次输入或输出。所以，选项C的说法是不正确的。

16. 以下语句或语句组中，能正确进行字符串赋值的是(     )。

A. char　*sp;　*sp="right!"; 　　 B. char s[10];　s="right!";

C. char　s[10];　*s="right!"; 　  D. char　*sp="right!";

答案：D；A char *sp;*sp="right!";不对sp是一个字符指针,然后再*sp就是一个字符的意思,它不可以赋值一个字符串；B char s[10];s="right!";s是一个数组名,数组名不可以赋值.；C char s[10];*s="right!";s是一个数组的首地址,它指向第一个元素.所以*s就是s[0]它也是一个字符,不可以赋值为字符串.其实赋值中,就是字符串赋值比较难；主要注意下字符串的初始化的两种形式char *sp="right!";另外char sp[]="right!";也可以.其他的如果不是初始化,纯赋值,主要是观察左右类型是否一致.不能左边是一个字符或者一个指针,而右边是一个字符串常量.