我们在写代码的时候难免要把数组或者指针传给函数，那函数的参数该如何设计呢？

数组传参

一维数组传参

我们首先来看下面代码的几个例子：

#include <stdio.h>
void test(int arr[])//ok?--Yes
{}
void test(int arr[10])//ok?--Yes
{}
void test(int* arr)//ok?--Yes
{}
void test2(int* arr[20])//ok?--Yes
{}
void test2(int** arr)//ok?--Yes
{}
int main()
{int arr[10] = {0};int* arr2[20] = {0};test(arr);test2(arr2);

🚩首先来看test(arr);
看看它的函数参数可以怎么写？

因为test(arr);传过去的是数组，所以上面的void test( ){}也可以用数组接收，
即写成void test(int arr[]){}
当然[]里可以写数组大小，也可以不写，里面的数字对语法没任何影响，所以我们还可以写做void test(int arr[10]){}或void test(int arr[30]){}(当然这样写30，虽然语法正确，但没任何意义)
上面的写法即是数组传参，形参写成数组的形式。

我们知道，数组传参本质上传过去的是数组首元素的地址，所以参数部分我们就可以写成指针了
我们来分析一下
test(arr);数组名arr是首元素的地址， int arr[10] = {0};可以看出每个元素的类型是int类型。
test(arr);传过去的是首元素的地址，首元素的地址是一个int类型的元素的地址，int类型元素的地址如果要用指针来接收，那就该用int类型指针来接收，所以可以写成void test(int* arr){}

🚩接下来我们来看 test2(arr2);
数组传过来，用数组接收，写做void test2(int* arr[20]){}以及void test2(int* arr[]){},原理同上面的test(arr);
那数组传参写成指针又怎么写呢？
数组传参本质上传过去的是数组首元素的地址， int* arr2[20] = {0};可以看出，首元素类型为int*，即每个元素都是个整型指针,所以int*类型元素的地址如果要用指针来接收，那就该用int*类型指针来接收，即一级指针地址传过去，就需要用二级指针来接收，所以可以写成void test(int** arr){}

二维数组传参

同样，我们首先来看下面代码的几个例子：

void test(int arr[3][5])//ok？--Yes
{}
void test(int arr[][])//ok？--No
{}
void test(int arr[][5])//ok？--Yes
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//ok？--No
{}
void test(int* arr[5])//ok？--No//int* arr[5]是指针数组 根本不沾边
{}
void test(int (*arr)[5])//ok？--Yes
{}
void test(int** arr)//ok？--No
{}
int main()
{int arr[3][5] = {0};test(arr);
}

有前面的分析，很容易知道可以这样写void test(int arr[3][5]){}
二维数组传参，函数形参的设计只能省略第一个[]的数字，即行可以省略，列不能省略。
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
这样才方便运算。
所以void test(int arr[][]){}这样写不行，
应该void test(int arr[][5]){}这样写。
我们要知道，当我们谈二维数组首元素地址的时候，指的是它的第一行

对于arr[3][5]这个数组，本质上是这样的，arr有三个元素，每个元素是（有五个整型元素的）一维数组，我们说数组名表示首元素的地址，即第一行一维数组的地址，一维数组的地址就要用指向一维数组的指针来存放，即写成void test(int (*arr)[5]){}数组指针的形式。
解释：arr是个指针，指向的是5个元素的数组，元素类型为int，（说明一下，(*arr)如果不加(),则arr会优先跟[5]结合，因为[]优先级更高）
不懂为什么这么写的可以去看这篇博客数组指针（用几个例子来看看用法）【点击即可跳转】
有人肯定在想，二维数组用二级指针可以吗？即void test(int **arr){}//ok？–No，当然不行啦，虽然它们都带有“二”，但二维数组和二级指针没有任何关系噢
那void test(int* arr)可以吗？也不行。二维数组名传过去的实际上是第一行一维数组的地址，这里就肯定不能用一个整型指针int* arr来接收（要用数组指针），整型指针是用来存放整型变量地址的。

指针传参

一级指针传参

int main()
{int arr[10] = {1,2,3,4,5,6,7,8,9};int *p = arr;int sz = sizeof(arr)/sizeof(arr[0]);//一级指针p，传给函数print(p, sz);return 0;
}

对于 print(p, sz);我们传参，函数print()的形参部分应该怎么写呢？
答案如下

void print(int *p, int sz)

我们要打印出来arr的元素，则整段代码为

#include <stdio.h>
void print(int *p, int sz)
{int i = 0;for(i=0; i<sz; i++){printf("%d\n", *(p+i));}
}
int main()
{int arr[10] = {1,2,3,4,5,6,7,8,9};int *p = arr;int sz = sizeof(arr)/sizeof(arr[0]);//一级指针p，传给函数print(p, sz);return 0;
}

有人肯定会问，一级指针用一维数组传可以吗？
即写成

void print(int p[], int sz)

运行一下

答案是：可以的。毕竟一维数组的本质还是指针。但是不建议这样写，还是对应写成指针的形式比较好，一级指针传过去就用一级指针接收比较好。

那接着我们思考一下
当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
比如：

void test1(int *p)
{}

test1函数能接收什么参数？

void test1(int* p)
{}
int main()
{int a;test1(&a);//整型的地址放到整型的指针里去，当然是可以的
}

还能怎样写?

void test1(int* p)
{}
int main()
{int arr[10] = { 0 };test1(arr);
}

数组名代表首元素地址，arr元素是int型的，所以对应上面int* p也是可以的。
当然，直接传一级指针过去也是可以的

void test1(int* p)
{}
int main()
{int a;int* p1 = &a;test1(p1);
}

二级指针传参

对于下面

int main()
{int n = 10;int*p = &n;int **pp = &p;test(pp);//传的是二级指针变量return 0;
}

test(pp);传的是二级指针变量，那就用二级指针接收。
即

 #include <stdio.h>
void test(int** ptr)
{printf("num = %d\n", **ptr); 
}
int main()
{int n = 10;int*p = &n;int **pp = &p;test(pp);return 0;
}

思考一下，当函数的参数为二级指针的时候，可以接收什么参数？
比如：

void test(int** ptr)
{}

test函数能接收什么参数？
当然还可以这样：

#include <stdio.h>
void test(int** ptr)
{printf("num = %d\n", **ptr); 
}
int main()
{int n = 10;int*p = &n;int **pp = &p;//test(pp);test(&p);//一级指针变量的地址取出来放到二级指针里面去return 0;
}

当然还可以这样：

#include <stdio.h>
void test(int** ptr)
{printf("num = %d\n", **ptr); 
}
int main()
{int* arr[10] = {0};test1(arr);
}

arr数组的元素类型是int*,数组名arr代表数组首元素的地址，即int*的地址，那么就可以放到二级指针里面去。即指针数组的数组名可以传过去。

以上就是我总结的关于"数组传参，指针传参"的相关内容
如果对你有帮助，别忘了点赞👍+收藏
欢迎大家的指导
我的主页还有其他内容，关注❤我，我们一起学习一起成长！