指针、数组作为函数参数传递的方式

淡淡的烟草味﹌ 2022-03-12 02:24 323阅读 0赞

#### 指针作为函数参数传递一维数组 ####

C 语言中声明了一个数组TYPE array\[n\]，则数组名称array 就有了两重含义：  
第一，它代表整个数组，它的类型是TYPE\[n\]；  
第二，它是一个常量指针，该指针的类型是TYPE\*，该指针指向的类型是TYPE。

因此，指针作为函数参数传递一维数组有4种形式：

#include <stdio.h>
    #define N 3
    float average1(float * g); 
    float average2(float grade[N]); 
    int main()
    {
    	float grade[N]={60,75,80};	
    	float * a = grade; //数组名类型是float *
    	printf("学生的平均成绩是：%.3f\n",average1(grade)); //数组名传递给指针
    	printf("学生的平均成绩是：%.3f\n",average2(grade)); //数组名传递给数组名
    	printf("学生的平均成绩是：%.3f\n",average2(a));     //指针传递给数组名
    	printf("学生的平均成绩是：%.3f\n",average1(a));     //指针传递给指针
    }
    float average1(float * g) //定义float *型的指针参数
    {
    	float *a=g; 
    	float ave,sum=0;  
    	for(;g<a+N;g++) {
    		sum+=*g;	}
    	return ave=sum/N;		
    }
    float average2(float grade[N])
    {
    	float ave,sum=0;  
    	for(int i=0;i<N;i++){
    		sum+=grade[i];}	
    	return ave=sum/N;		
    }
    
       
        
         1
         2
         3
         4
         5
         6
         7
         8
         9
         10
         11
         12
         13
         14
         15
         16
         17
         18
         19
         20
         21
         22
         23
         24
         25
         26
         27
         28

#### 二维数组和二级指针的传递 ####

**1、定义指针变量`int *`型与二维数组的关系**  
在一维数组中，数组名表示的是数组第一个元素的地址，二维数组就是一维数组，例如：二维数组 `a[3][4]`，就是有三个元素 `a[0]、a[1]、a[2]`的一维数组，所以数组 a 的第一个元素不是 `a[0][0]`，而是 `a[0]`，所以数组名 a 表示的不是元素`a[0][0]`的地址，而是 `a[0]`的地址，即：  
a == &a\[0\];  
而 `a[0]` 又是 `a[0][0]`的地址，即：

a[0] == &a[0][0];
    
       
        
         1

所以二维数组名 a 和元素 `a[0][0]`的关系是：

a == &(&a[0][0]);
    
       
        
         1

即二维数组名 a 是地址的地址，必须两次取值才可以取出数组中存储的数据。对于二维数组`a[M][N]`，数组名 a 的类型为`int(*)[N]`，所以如果定义了一个指针变量 p：`int *p;`并希望这个指针变量指向二维数组 a，那么不能把 a 赋给 p，因为它们的类型不一样。要么把`&a[0][0]`赋给 p，要么把 `a[0]` 赋给 p，要么把`*a` 赋给 p。因为 `a==&(&a[0][0])`，所以 `*a==*(&(&a[0][0]))==&a[0][0]`。  
**2、定义指针变量 `int(*)[N]` 型与二维数组的关系**  
当指针变量 p 定义成 int(\*)\[N\] 型，这时就可以把 a 赋给 p。`p == a;`  
那么此时p以“行”为单位 指向元素`a[i][j]`。数组名 a 代表第一个元素 `a[0]`的地址，则`a+1`就代表元素 `a[1]`的地址，即`a+1==&a[1]`；`a+2`就代表 `a[2]`的地址，即 `a+2==&a[2]`……`a+i`就代表 `a[i]`的地址，即

a+i == &a[i];
    p+i == &a[i];
    *(p+i) == a[i]; //等式两边作“*”运算
    *(p+i) + j == &a[i][j]; //等式两边同时加上j行
    
       
        
         1
         2
         3
         4

（1）当二级指针（例如：类型为`int **`）作为函数形参时，能作为函数实参的是二级指针，指针数组（例如：类型为`int *[]`），一级指针的地址 （例如：类型为`int **`）  
（2）当数组指针作为函数形参时，能作为函数实参的是二维数组（例如：类型为`int(*)[N]`），数组指针（例如：类型为`int(*)[N]`）  
（3）当二维数组作为函数形参时，能作为函数实参的是二维数组，数组指针  
（4）当指针数组作为函数形参时，能作为函数实参的是指针数组，二级指针,一级指针的地址

#include <stdio.h>
    #include <stdlib.h>

void fun1(int \*\*pp)  
\{  
printf(“fun1\\n”);  
\}  
void fun2(int(\*c)\[5\])  
\{  
printf(“fun2\\n”);  
\}  
void fun3(int a\[\]\[5\])  
\{  
printf(“fun3\\n”);  
\}  
void fun4(int \*pa\[5\])  
\{  
printf(“fun4\\n”);  
\}

int main()  
\{  
int \*pa\[5\]; //指针数组  
int \*\*pp = NULL; //二级指针  
int \*p = NULL; //一级指针  
int a\[5\]\[5\]; //二维数组  
int b\[5\]; //一维数组  
int(\*c)\[5\] = &b; //数组指针  
// 当二级指针作为函数形参时，能作为函数实参的是二级指针，指针数组，一级指针的地址  
fun1(pa);  
fun1(pp);  
fun1(&p);  
printf("\\n");  
// 当数组指针作为函数形参时，能作为函数实参的是二维数组，数组指针  
fun2(a);  
fun2©;  
printf("\\n");  
// 当二维数组作为函数形参时，能作为函数实参的是二维数组，数组指针  
fun3(a);  
fun3©;  
printf("\\n");  
// 当指针数组作为函数形参时，能作为函数实参的是指针数组，二级指针,一级指针的地址  
fun4(pa);  
fun4(pp);  
fun4(&p);  
printf("\\n");  
return 0;  
\}