C语言进阶 - 指针2 - 知识点整理
目录
一、一维数组传参：
二、二维数组传参：
三、一级指针传参：
四、二级指针传参：
五、函数指针：
六、俩段有趣的代码：
七、函数指针数组：
八、函数指针数组的应用：计算器
九、辨认3个指针：
1.指向整形数组的指针
2.指向整形指针数组的指针
3.指向函数指针数组的指针
一、一维数组传参：
//代码1：
//一维数组传参，既可以写成数组，也可以写成指针
//1.
void test(int arr[])
{}
//2.
void test(int arr[10])
{}
//3.
void test(int *arr)
{}
//1.
void test2(int* arr[20])
{}
//2.
void test2(int** arr)
{}
int main()
{
int arr[10] = {0};
int* arr2[20] = {0};
test(arr);
test2(arr2);
}二、二维数组传参：
//代码2：
//二维数组传参
void test(int arr[3][5])
{}//ok
void test(int arr[][])//可以省略行，但不可以省略列
{}//err
void test(int arr[][5])
{} //ok
void test(int (*p)[5])//第一行的元素，一共是5个元素，每一个元素是int 型，所以用一维数组的指针去接收
{}//ok，数组用数组指针去接收
int main()
{
int arr[3][5] = {0};
test(arr);//arr表示的是首元素地址，而首元素表示的是第一行的地址，也就是一个一维数组--第一行中的5列,数组用数组指针来接收
//传过去的是一维数组的地址，那么用一维数组的指针去接收
return 0;
}
三、一级指针传参：
//代码3：
//一级指针传参
void print(int* p ,int sz)//指针p是一级指针，所以用一级指针接收
{
//数组元素
int i = 0;
for (i = 0;i < sz;i++)
{
printf("%d ",p[i]);
}
}
int main()
{
int arr[] = {1,2,3,4,5,6};
int*p = arr;//首元素地址
int sz = sizeof(arr) / sizeof(arr[0]);
print(p,sz);
return;
}四、二级指针传参：
//代码4：
//二级指针传参
void test(int **ppa)
{}
int main()
{
int a = 10;
int* pa = &a;
int** ppa = &pa;
int* arr[5];
test(ppa);//方式1
test(&pa);//方式2
test(arr);//方式3：arr代表首元素地址，首元素是int* 类型，int* 类型的地址则用二级指针接收
//指针数组的数组名用二级指针接收
return 0;
}五、函数指针：
//代码5：
//整形指针 -- 存放整形的地址
//字符指针 -- 存放字符的地址
//数组指针 -- 存放数组的地址
//函数指针变量 -- 存放函数的地址
//&数组名 -- 数组的地址
//数组名 -- 数组首元素的地址
int Add(int x,int y)
{
return x + y;
}
int main()
{
printf("%p\n",&Add);//007F13E3
printf("%p\n",Add);//007F13E3
//函数名
//&函数名 俩者所表示的地址是一样的
//数组指针
int arr[10] = {0};
int(*parr)[10] = &arr;//*parr表示parr是一个指针，[10]表示arr指向10个元素的数组，int 表示数组里面的每个元素是int 类型
//函数指针
int (*pf)(int,int)= &Add;//*pf 表示pf是一个指针，(int,int)表示参数类型，int表示返回类型
//总结类型：去掉函数名就是类型
int a = 10;//int
int arr[10];//int [10]
int(*parr)[10] = &arr;//int (*)[10] ,parr就是数组指针变量
int (*pf)(int, int) = &Add;//int(*)(int,int)
//pf是用来存放函数的地址 - pf就是函数指针变量
//函数指针的应用:有时拿到的不是函数，而是函数的地址
//1.常规应用
int ret = Add(2,3);
printf("%d",ret);//5
//2.函数指针
//写法一：写成这样是为了让初学者更好的理解 -- 取地址然后解引用
int(*pf)(int, int) = &Add;
ret = (*pf)(3, 4);//通过先解引用pf，找到Add()这个函数，然后在执行
printf("%d", ret);//7
return 0;
//写法二： 因为&Add和Add都表示函数地址，所以也可以直接写成Add
int(*pf)(int, int) = Add;//此处Add和pf类型一样,所以pf和Add是同一回事
ret = pf(3, 4);//所以可以直接用pf,直接调用
printf("%d", ret);//7
}
六、俩段有趣的代码：
//代码6：
typedef void(* pfun_t)(int);//把void(*)(int) 重新定义为pfun_t
//typedef int int32 //但是上面写成这样的形式语法不允许
int main()
{
//代码1：
(*((void(*)()) 0))();
//该代码是一次函数调用
//解析：
//1.代码中把0强制转换为类型为void(*)()的一个函数的地址
//2.解引用0地址，就是去调用0地址出的这个函数，被调用的函数是无参，返回类型是void
//代码2
void (*signal(int, void(*)(int)))(int);
//这个代码是一次函数声明
//声明的函数名为signal
//signal函数有俩个参数，第一个是int类型，第二个是void(*)(int)的类型
//signal函数的返回类型依然是:void(*)(int)的函数指针类型
//去掉函数名及参数就是返回类型，如int Add();int即为返回类型
//上面的声明代码即可简化成如下形式：
pfun_t signal2(int,pfun_t);
}
七、函数指针数组：
//代码7：
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* arr[10];//存放整形指针的数组
//函数指针数组 -- 存放函数指针的数组
int (*pf1)(int,int) = Add;
int (*pf2)(int, int) = Sub;
int (*pf3)(int, int) = Mul;
int (*pf4)(int, int) = Div;
//函数指针数组 --- 首先是一个数组
int (*pfArr[4])(int, int) = {Add,Sub,Mul,Div};
//pfArr[4]是一个数组，4个元素，每个元素的类型是一个int (*)(int, int)-- 函数指针
}
八、函数指针数组的应用：计算器
//代码8：
//各函数， 参数，类型，相同，所以可以应用函数指针数组
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;
}
void menu()
{
printf("1.add 2. sub 3. mul 4.div 0.exit\n");
}
int main()
{
int (*pfArr[5])(int, int) = {0,Add,Sub,Mul,Div};
// 0 1 2 3 4
int input = 0;
do
{
menu();
printf("请选择\n");
scanf("%d",&input);
int x = 0;
int y = 0;
if (input == 0)
{
printf("退出计算器\n");
}
else if (input >= 1 && input <= 4)
{
printf("请输入俩个操作数\n");
scanf("%d%d", &x, &y);
int ret = pfArr[input](x, y);
printf("%d\n",ret);
}
else
{
printf("请重新输入");
}
} while (input);
return 0;
}
九、辨认3个指针：
1.指向整形数组的指针
2.指向整形指针数组的指针
3.指向函数指针数组的指针
//代码9：
//举例一：
int arr[10];//整形数组
int (*p)[10]= &arr;//int [10] ，p是一个指针，指向一个数组，数组有10个元素，每个元素的类型是int型
//所以p是一个指向整形数组的指针
//举例二：
int* arr[10];//整形指针数组
int* (*p)[10] = &arr;//整形指针数组的地址
//p是一个指针，指向一个数组，数组有10个元素，每个元素的类型是int*型
//所以p是一个指向 ( int* [10]) 整形指针数组的指针
//举例三：指向函数指针数组的指针
int Add(int x,int y)
{
return x + y;
}
int main()
{
int (*p)(int, int) = Add;//Add表示的是函数的地址，函数的地址用函数指针来接收
int (*pA[5])(int, int);//pA是一个函数指针的数组,pA是一个数组，数组里面存放着函数指针类型
int(*(*pAA)[5])(int,int) = &pA;//首先接收的应该是一个指针，这个指针指向一个数组，数组里面的每个元素都应该是函数指针类型，就是用一个指针去指向上面的数组
//pAA是一个指向函数指针数组的指针
}本文为指针部分的知识点整理，如有误，请评论区多多评论，感谢