莫道君行早，更有早行人。— 出自《增广贤文·上集》
解释：别说你出发的早，还有比你更早的人。
这篇博客我们将会深入的理解数组传参和函数指针等指针，是非常重要的内容，学好这部分才能算真正学懂C语言。
一维数组传参🍀
我们必须要对这方面理解透彻，才能让我们在写函数形参的类型时，有更清晰的理解
我们来看一段代码
#include <stdio.h>
void test(int arr[])//ok?
{}
void test(int arr[10])//ok?
{}
void test(int *arr)//ok?
{}
void test2(int *arr[20])//ok?
{}
void test2(int **arr)//ok?
{}
int main()
{
int arr[10] = {0};
int *arr2[20] = {0};
test(arr);
test2(arr2);
}
这个题目就是想问test 和test2这两个函数哪些形参是对的哪些又是错误的。
- 简单的分析
主函数里有一个整型数组 arr和一个指针数组存放整型指针，test(arr)实参是arr的地址，test2(arr2)的实参是arr2的地址。现在你可以试一试。
- 开始真正分析
void test(int arr[])//ok?
{}
void test(int arr[10])//ok?
{}
void test(int *arr)//ok?
{}
前面两个个应该是属于我们还没有学指针时，形参的写法，这两种也都是对的。第三个是我们学习指针之后的写法，也是正确的。
但是我们还是要说明一下其中的知识点。
如果数组的实参是arr,数组的形参可以写成int arr[ ],int arr[10],或者int * arr。那么[10]和[ ]的区别在哪里呢？
- 实际上这两个没有区别，只是给人的观感不同，为什么呢？
- 我们知道将数组名arr传给形参，形参并不会创建一个数组，而只是用变量记录这个地址，
- 而int [ ]的本质其实就是int * arr，这个[]中写数字其实是没有意义的，因为我们不会再创建一个数组，因为实际上传的还是指针，也就是说数字可以随便写，比如[1000]但是呢？为了不然别人理解错误最好只写int arr[].
然后我们看剩下两个
void test2(int *arr[20])//ok?
{}
void test2(int **arr)//ok?
{}
int *arr2[20] = {0};
test2(arr2);
- 分析:
其实指针数组与一维数组是类似的，只是两个数组存储的元素类型不一样。
我们传参传的还是首元素的地址，首元素地址，可以用一样的类型来接收，就想上面我们说的一样。因为这里并不会创建一个数组，只是将数组首元素地址传过去。所以第一个就是正确的。其实我们也还可以想上面的例子一样,这样写
void test2(int *arr[200])
{}
- 那么第二个呢？我们知道arr2的首元素是int *,那么int *类型的地址应该用什么接收呢？ 当然是二级指针，一级指针的地址肯定用二级指针来接收。
int a = 10;
int *p = &a;
int **pp = &p;
这样的例子应该会更容易理解。
二维数组传参🐽
咱们不要觉得数组传参都是一样的
我们来看看二维数组到底区别在哪。
void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
void test(int *arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int (*arr)[5])//ok？
{}
void test(int **arr)//ok？
{}
int main()
{
int arr[3][5] = {0};
test(arr);
}
- 简单的分析
简单定义并初始化了一个数组名为arr的二维数组。然后将数组名传参。 - 开始真正分析
- 先从没有 * 号开始吧。
void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
我们可以看到这三种不同的写法的区别就在于[ ][ ]中的数字到底是多少，
首先联想一下我们的一维数组传参，[ ]里可以写也可以不写。
那么二维数组就不一样了，我们必须传过去列，行则是传不传都可以，我们可以联想一下我们二维数组的初始化。
这样我们就能明白了，第一个和第三个是正确的。
- 然后我们看带*号的。
void test(int *arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int (*arr)[5])//ok？
{}
void test(int **arr)//ok？
{}
int main()
{
int arr[3][5] = {0};
test(arr);
}
在二维数组传数组名的时候，我们必须知道，这个数组名代表什么意思。
从我举的这个例子：二维数组的数组名确实是二维数组的第一行的地址，并且+1就到了第二行的首元素地址。
void test(int *arr)//
{}
void test(int* arr[5])//
{}
void test(int (*arr)[5])//
{}
void test(int **arr)//
{}
第一个：肯定不行，整型指针一般接收整型元素的地址，我这里可是二维数组的第一行的地址，即一个一维数组的整个数组的地址。
第二个：这是一个指针数组，肯定不行，因为类型都对不上，我这里是一个数组的地址，放到一个数组里面肯定不行。起码你要是一个指针啊。
第三个：这个就是正确的，为什么呢？数组指针指向的就是数组，而我们这里恰好可以看作一个一维数组，也就是说可以将这个一维数组的地址存放到arr这个变量中。
第四个：也是错误的，为什么？二级指针用来接收一级指针的地址，这里完全不搭啊。
最后还有一个不常用的内容，大家看看就好。
void test1(int (*p)[5])
{}
void test2(int(*p)[3][5])
{
*p;
}
int main()
{
int arr[3][5];
test1(arr);//传递的第一行的地址
test2(&arr);//传递的是整个二维数组的地址,很少这样传
return 0;
}
一级指针传参🦑
上面我们已经解析过数组的传参接下来我们试试指针，我们先从一级指针开始：
#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;
}
- 简单的分析
创建一个arr数组并初始化，让int * p 指向这个数组，p中存储的是arr这个数组的首元素地址，再传p变量也就是arr的地址。整型元素的地址用一级指针接收是正确的。
了解了这一部分，那么下一个问题。
思考： 当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
其实很简单，（以整型元素为例）只要你传的是一个整型元素的地址就行。
void test(int* ptr)
{
//...
printf("%p\n", ptr);
}
int main()
{
int a = 10;
int* p = &a;
int arr[10];
test(arr);//数组
test(&arr[0]);
test(&a);//p是一级指针
test(p);
return 0;
}
这就是一级指针传参的内容。
二级指针传参🐸
上面我们介绍了一级指针传参，下面我们看看二级指针到底在传参时有什么不同。
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;
}
这里我们注意一下 ** ptr，我们解引用一次得到p的地址，p的地址再解引用一次就得到n 也就是10。
二级指针我们知道，是用来接收一级指针地址的（注意指针变量的地址不要与指针变量中存储的地址搞混淆），那么一级指针地址有几种表示方法呢？
int n = 10;
int*p = &n;
int **pp = &p;
test(pp);
test(&p);
这里就是答案。
思考： 当函数的参数为二级指针的时候，可以接收什么参数
void test(int** ptr)
{
printf("%p\n", **ptr);
}
int main()
{
int a = 10;
int* p = &a;
int** pp = &p;
test(&p);
test(pp);
int* arr[10] = { p };
test(arr);
test(&arr[0]);
return 0;
}
我们从二级指针接收一级指针的地址作为突破口，
那么除了这两种还有一类。
test(&p);
test(pp);
那就是指针数组，指针数组的每个元素都是指针变量的地址，这样我们就能理解了。
函数指针🥶
我们都知道变量是有地址的，那么函数有地址吗？
肯定也是有点既然有地址那么就可以与指针有联系。
这就是我们将会介绍的函数指针。
我们来看一段代码：
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);//直接打印函数名
printf("%p\n", &test);//取函数的地址打印
return 0;
}
发现这两种写法其实是一样的。
那我们的函数的地址要想保存起来，怎么保存？
下面我们看代码：
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();
答：pfun1可以存放。
pfun1先和结合，说明pfun1是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为void。
我们已经学会了这么函数指针的一般表达方式，那么我们来尝试使用使用。
使用函数指针
int Add(int a, int b)
{
return (a + b);
}
int main()
{
int x = 5;
int y = 3;
printf("%d\n", Add(x, y));
int (*p1)(int, int) = Add;
int (*p2)(int, int) = &Add;
printf("%d\n", p1(5,3));
printf("%d\n", (*p2)(5, 3));
printf("%d\n", Add(5,3));
printf("%d\n", (&Add)(5, 3));
return 0;
}
我们看到这几种写法都是可以的，
printf("%d\n", p1(5,3));
printf("%d\n", (*p2)(5, 3));
printf("%d\n", Add(5,3));
printf("%d\n", (&Add)(5, 3));
p1和p2都是存储Add函数的地址，而函数名就相当于函数地址（p1 | p2 == Add），那么解引用实际上有没有都一样，哪怕你写（********p2）都行，并没有什么太大的意义。
我们已经学会了函数指针的写法和用法接下来我们出两个题目。
//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);
我们不要畏惧这种代码其实只要我们用心加上经验就能看出来。
开始分析
(*(void (*)())0)();
首先我们能看到void ( * )( )这个函数指针和0我们看到( * )里面没有写变量，
那么说明这是一种类型，而0是什么呢？其实这里的0指的是0地址
(void ( * )( ))0那么这一部分的意思就是将0地址的类型转换为
void ( * )( )
这就意味着0地址处放一个返回类型是void，无参的一个函数
现在我们可以把代码简化一下变成：( * 0)( );也就是说调用0地址处的函数刚好也
与我们void ( * )( )相对应，只是我们不需要再写返回值，只需要写参数
这里刚好无参
这就是在表达调用0地址处的这个函数void (*signal(int , void(*)(int)))(int);
我们还是先从内部找我们认识的，(int, void( * )(int))这是一个函数的参数
第一个参数是int,第二个参数是一个函数指针
那么signal就应该是函数名
我们去掉这部分再观察void ( * )(int);
我们看到只剩下这一部分，还是一个函数指针类型，那这
是什么意思呢？其实是函数指针的返回值的表达形式
也就是说signal函数的返回值类型也是：void( * )(int)的函数指针
这就是我们所讲解的函数指针类型。
函数指针数组🐣
上面我们讲解了函数指针，现在我们来看看函数指针数组又不同在哪一点
我们知道指针数组是这样的：
int *p[5] p先和[]结合，说明是数组然后，int * 为类型
那么函数指针数组呢?
其实只需要把类型变换一下
int (*parr[5])(int ,int)
parr1 先和 [ ] 结合，说明 parr1是数组，数组的内容是什么呢？
是 int (*)() 类型的函数指针。
然后我们看一下到底如何使用
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mul(int x, int y)
{
return x * y;
}
int Div(int x, int y)
{
return x / y;
}
int main()
{
int (*parr[4])(int, int) = { Add,Sub,Mul,Div };
printf("%d\n", (parr[0](4, 2)));
printf("%d\n", (parr[1](4, 2)));
printf("%d\n", (parr[2](4, 2)));
printf("%d\n", (parr[3](4, 2)));
return 0;
}
其实函数指针数组的用途：转移表
void menu()
{
printf("**************************\n");
printf("**** 1.add 2.sub ****\n");
printf("**** 3.mul 4.div ****\n");
printf("**** 0.exit ****\n");
printf("**************************\n");
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
//转移表
int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
}
else if (input >= 1 && input <= 4)
{
printf("请输入2个操作数:>");
scanf("%d%d", &x, &y);
ret = pfArr[input](x, y);
printf("ret = %d\n", ret);
}
else
{
printf("选择错误\n");
}
} while (input);
return 0;
}
为什么要这样呢？
如果我们不使用转移表那么就会写出多个case，这样做可以减少代码的冗余，简单明了。
指向函数指针数组的指针🦄
这也是我的博客中指针类型的最后一种，我们看到标题的最后是什么什么的指针，那么说明就是一个指针只不过类型复杂了那么一点。
int Add(int x, int y)
{
return x + y;
}
int main()
{
int arr[10] = {1,2,3,4,5,6,7};
int(*p)[10] = &arr;//p得是数组指针
int* arr2[5];
int* (*p2)[5] = &arr2;//p2则是指针数组
//函数指针
int (*pf)(int, int) = &Add;
//函数指针数组
int (* pfarr[4])(int, int);
int (* (*p3)[4])(int, int) = &pfarr;
//p3是一个指向函数指针数组的指针
return 0;
}
注意指向函数指针数组的指针的写法。
(*p3)是指针然后再将类型往外面套就行了。
int ( * [4])(int, int) = &pfarr;也就是这一部分。
接下来看看应该如何使用呢？
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mul(int x, int y)
{
return x * y;
}
int Div(int x, int y)
{
return x / y;
}
int main()
{
int (*parr[4])(int, int) = { Add, Sub, Mul, Div };
int (*(*p)[4])(int, int) = &parr;
for (int i = 0; i < 4; i++)
{
int ret = (*p)[i](4, 2);
printf("%d\n", ret);
//int ret = p3[0][i](3, 4);
//printf("%d\n", ret);
}
return 0;
}
这便是如何使用。
总结😈
我们在这篇博客中详细的介绍了详数组传参指针传参的方法和细节，以及一些不太常用但是你必须要知道的一些指针类型，貌似在操作系统开发上用的比较多。完结。
扫一扫
9388
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
