千字解析指针进阶

目录

1.指针的含义

2.指针变量作为函数参数

3.指针数组

4.数组指针

4.1二维数组用数组传参，用数组指针实现

*5.函数指针

5.1函数指针数组

6.函数指针的回调

---

1.指针的含义

前面学过了初级指针的知识，指针指向一个变量或者常量的地址，可以通过指针变量来修改指向地址的内容。

指针的定义方式为类型名*指针变量名称,int*p.

以上只是指针的基础知识。

2.指针变量作为函数参数

函数的参数不仅可以是整形，浮点型，字符型。还可以是指针类型。它的作用是将一个变量的地址传送到另一个函数中。

void swap(int* p, int* n)
{
	int x = 0;
	x = *p;
	*p = *n;
	*n = x;
}
int main()
{
	int a, b;
	int* p, * n;
	scanf("%d %d", &a, &b);
	p = &a, n = &b;
	if (a < b)
	{
		swap(p, n);
	}
	printf("%d %d", *p,*n);
	return 0;
	
}

以上代码是指针作为函数参数传参，如果其中的函数写成以下就会有问题

void swap(int* p, int* n)
{
	int*x ;
	*x = *p;
	*p = *n;
	*n = *x;
}

这段代码就会有问题，因为int*x是一个指针变量，并未指定int*x所指向的内容。程序就会出问题的。

3.指针数组

见名思意所谓指针数组就是指针的数组，平时有整型数组，字符数组，指针数组就是存放指针的数组，指针数组是一个数组里面存放着指针。int*p[10]为指针数组的定义形式，p为数组名称，里面有是个元素，每个元素为整形指针。

#include<stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int d = 40;
	int* p[5] = { &a,&b,&c,&d };//里面每个元素都为变量的地址；
	return 0;
}

int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	int d = 40;
	int* p[5] = { &a,&b,&c,&d };//里面每个元素都为变量的地址；
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", *p[i]);
	}
	return 0;
}

再看下面的代码

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	int* p[] = { arr1,arr2,arr3 };
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			
			printf("%d ", p[i][j]);
			printf("%d ", *(*(p+i)+j));
		}
		printf("\n");
	}
	return 0;
}

 上面代码两个打印函数结果相同。其实就是地址的含义，p[i][j]==*(*(p+i)+j)含义相同的。

int main()
{
	char* p[] = { "abcde","sfiuasa","bitch","fauc" };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%s", p[i]);
		printf("\n");
		printf("%s", *(p+i));
		printf("\n");
	}
	return 0;
}

这段代码是对指针字符数组的打印因为%s，这个函数会一直打印到/0，才会停止这里注意p[i]==*(p+i).

4.数组指针

和指针数组不同的是这是数组的指针，意思就是存放数组的指针，那么数组指针什么意思呢？

我们都知道有整形指针和字符指针，那么数组指针就是可以指向数组的指针，数组指针定义方式为

int (*p)[10]首先为一个指针，指向了10个元素，每个元素为int型。

int main()
{
	int* p[10] = { 0 };
	int*(*n)[10]= &p;//指向10个元素的*n指针，每个元素为int*型；
	return 0;
}

在看下面一段代码

void print(int(*p)[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", (*(p+0))[i]);
		}
	printf("\n");
	for (i = 0; i < sz; i++)
	{
		printf("%d ", (*p)[i]);//这里的(*p)[i]和上面的（*(p+0)[i]）是等价的
	}
}

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(&arr, sz);
	return 0;
}

上面这段代码主要就是把数组的地址传了过去，导致后续的打印工作变的很麻烦也很不容易理解。所以说这种数组指针不要乱用。

4.1二位数组用数组传参，用数组指针实现

以上的代码都是用一维数组来证明数组指针的用处，不过用处好像并不太实用，下面介绍一下二位数组对数组指针的使用方法。

move(int (*p)[5], int r, int c)//这里接收就用数组指针接受，指针*p指向了每行的五个元素
                                //每个元素都是int型。
{
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i)+j));//*(p+i)先对每行解引用，然后加上每行的元素解引用
            printf("%d ", p[i][j])//下标法就非常容易理解
		}                                // *(*(p + i)+j）这样才可以找到每行每列的元素！
		printf("\n");                    //如果用下表法就会变得非常简单
	}
}

int main()
{
	int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 };
	move(arr, 3, 5);//这里数组传参依旧传递是首元素地址。但是上面接受的却不一样
	return 0;       //因为二维数组传参相当于把第一行的地址传了过去，
}

*5.函数指针

到目前已经学习了整形指针，字符指针，指针数组，数组指针，却还有一个非常重要的函数指针，

其实所谓函数指针也就是存放函数地址的指针

 从这里我们可以看出函数的地址也可以打印出来，好像c语言的一切东西，包括常量变量都有地址，那么有地址就可以通过指针找到。

int add(int x, int y)
{
	return x + y;
}
int main()
{
	int a = 10;
	int b = 20;
	add;
	int (*p)(int, int) = add;//定义了指针类型，指向了函数的地址
	int sum = (*p)(1, 6);//通过指针找到函数地址，并把函数参数传过去
	printf("%d",sum);
	return 0;
}

5.1函数指针数组

有了函数指针，就可以通过指针找到函数的地址并且调用这个函数，如果一个main函数里面有多个函数呢，总不能创建和函数一样多的指针再一一调用把，这里就想到了函数指针数组。比如一个main函数里面调用了好几个功能不同但是参数相同的函数。就可以使用函数指针数组来完成。

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 a = 8;
	int b = 2;
	int (*p[4])(int, int) = { add,sub,mul,div };
	return 0;
}

解析：函数指针数组，首先为一个数组，数组里面放什么呢，放的是函数的指针，也就是函数的地址。

下面可以利用函数指针数组来实现一个计算器

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***********\n");
	printf("*******3.mul   4.div***********\n");
	printf("*******0.exit       ***********\n");
	
}
int main()
{
	int input = 0;
	int a, b;
	do
	{
		menu();
		printf("请输入：>");
		scanf("%d", &input);
		int (*p[5])(int, int) = { 0,add,sub,mul,div };
		if (input == 0)
		{
			printf("退出程序\n");
				break;
		}
		else if (input >= 1 && input <= 4)
		{
			printf("请输入两个操作数:>");
			scanf("%d %d", &a, &b);
			int ret=p[input](a, b);
			printf("%d\n", ret);
		}
		
	} while(input);
	return 0;
}

这里的计算器的实现就利用了函数指针数组，比一个一个去调用函数效率高，而且工作量少。

最主要的一点是里面利用了p[input]这个函数指针数组；

6.函数指针的回调

声明：回调函数是通过函数指针调用的函数。如果你把函数的指针作为函数参数传给另一个函数，当这个指针被用来调用其所指向的函数时，我们称之为回调函数。

int add(int x, int y)//这里定义一个加法函数
{
	return x + y;
}
int sub(int x, int y)//定义一个减法函数
{
	return x - y;
}
void cala(int (*p)(int, int))//这边就用函数指针接受，但是调用这个函数的时候不是在这一步
{
	int ret = p(7, 5);//而是在这里才调用add和sub函数
	printf("%d", ret);
}

int main()
{
	cala(add);//cala函数参数为一个函数的地址
	printf("\n");
	cala(sub);
	return 0;
}

以上代码说明被回调的函数是在特定情况下才会执行。