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是一个指向函数指针数组的指针
}

本文为指针部分的知识点整理，如有误，请评论区多多评论，感谢😄