【指针进阶全】

指针回顾：
1.指针是一个变量，用来指向一个对象，本质就是存放指向对象的地址。
2.指针的大小在32位平台上占4字节，64位平台上占8字节。
3.指针的指向类型十分关键，决定着指针本身的定义。
4.&是取地址运算符，*是间接运算符

一、字符指针

1.案列引入

1.字符指针讲解通过下面一道题的解决来学习

#include 
int main()
{
 char str1[] = "hello bit.";
 char str2[] = "hello bit.";
 const char *str3 = "hello bit.";
 const char *str4 = "hello bit.";
 if(str1 ==str2)
 printf("str1 and str2 are same\n");
 else
 printf("str1 and str2 are not same\n");
 
 if(str3 ==str4)
 printf("str3 and str4 are same\n");
 else
 printf("str3 and str4 are not same\n");
 
 return 0;

2.结果分析

经过分析，此题结果是str1 and str2 are not samestr3 and str4 are not same，原因：
1.str1[]和srt2[]是数组，分别存放了"hello bit."存于内存中，取地址时，自然也是有两个不同的地址。所以str1！=str2.
2.str3和str4是一个字符型指针，他们都指向了一块相同的空间，都指向"hello bit."的地址。所以str1=str2.
还需注意的地方是代码char *str4 = "hello bit."中的str4指针，指向的是字符串首地址，也就是h字符的地址。通过以下代码验证

#include
int main()
{
	const char* p = "hello bit.";
	printf("%s", p);
	printf("%c", *p);
	return 0;
}

二、指针数组

1.指针数组的定义

从小学习语文便知，主语在后，前面是修饰。所以，所谓指针数组其实就是个数组，只不过这个数组是用来存放指针的。

2.指针数组的种类

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5]; //二级字符指针的数组

3.具体使用案例----模拟二维数组

#include
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 7,6,5,4,3 };
	int arr3[] = { 9,10,3,4,6 };
	//定义一个指针数组
	//存放每一个一维数组的地址，相当于二维数组
	int* a[3] = { arr1,arr2,arr3 };
	//打印模拟二维数组元素
	int i = 0,j = 0;
	for (i = 0; i < 3; i++) {
		for (j = 0; j < 5; j++) {
			printf("%d ", a[i][j]);
		}
		printf("\n");
	}
	return 0;
	
}

打印结果

三、数组指针

1. 数组指针的定义

数组指针是一个指针，用来指向一个数组
定义为：int( * p)[n]; （注意优先级：()>[]> *）

2. 一维数组中的用法

int (*p)[10];//指向一维数组int[10];

这里的p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。

3.二维数组中的用法

int a[3][4];
p=a;           //将二维数组的首地址赋值给p，也可是a[0]或&a[0][0]
p++;           //表示p跨过行a[0][],指向了行a[1][]

注意：这里的指针P指向二维数组首地址，当进行指针运算：如（P+1）时，会将一行看作是一个元素，p+1其实是跳向了第二行数组。

4.具体使用案例

main中的二维数组如何给函数传参呢？-
方法一：使用二维数组方式来接收

void print_arr1(int arr[3][5], int row, int col)
{
	int i = 0, j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

方法二：传递数组指针

void print_arr2(int(*arr)[5], int row, int col)
{
	int i = 0, j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

主函数

int main()
{
	int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
	print_arr1(arr, 3, 5);
	//数组名arr，表示首元素的地址
	//但是二维数组的首元素是二维数组的第一行
	//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
	//可以数组指针来接收
	print_arr2(arr, 3, 5);
	return 0;
}

使用数组指针传参，一般在二维数组中使用。

四、数组名详解

我们在取地址时，经常会使用&取地址符。但是在具体使用时，尤其时取数组的时候，内部有很多细节都没有注意。下面我们将初步学习相关知识。

1.数组名的理解：

数组名是数组首元素地址
但是有两个例外：
1.sizeof（数组名）；这里不是数组元素首地址，数组名表示整个数组
2.&数组名：数组名表示整个数组
除此之外，所有的地方的数组名都是数组元素的首地址。

2.案例分析1

int main()
{
	int arr[10] = {0};
    printf("%p\n",arr);
	printf("%d\n", &arr);
	printf("%d\n", &arr[0]);
	return 0;
}

打印结果

不是说&数组名，取的是整个数组的地址吗，为什么结果一样呢？
原因很简单：其实&arr时，虽然说是要取整个数组地址，但是他也选取首元素作为整个数组的地址，所以结果一样。

通过调试也可得出相同结论。

案例分析2

#include 
int main()
{
 int arr[10] = { 0 };
 printf("arr = %p\n", arr);
 printf("&arr= %p\n", &arr);
 printf("arr+1 = %p\n", arr+1);
 printf("&arr+1= %p\n", &arr+1);
 return 0;
}

打印结果

分析：arr+1和&arr+1结果不一样，就很好说明了&数组名是取整个元素地址。因为&arr+1是跳过了整个数组之后才+1。

五、函数指针

函数指针 的本质是一个指针，该指针的地址指向了一个函数，所以它是指向函数的指针。

1. 其声明形式如下所示：

ret (*p)(args, ...);

其中， ret为返回值，* 与p结合说明p是一个指针变量，指向该类型函数，args为形参列表。其中p被称为函数指针变量 。

2.函数指针的初始化:

函数指针变量 =  函数名;

3. 下面通过一个具体案例学习

#include 

int max(int a, int b)
{
    return a > b ? a : b;
}

int main(void)
{
    int (*p)(int, int); //函数指针的定义
    //int (*p)();       //函数指针的另一种定义方式，不过不建议使用
    //int (*p)(int a, int b);   //也可以使用这种方式定义函数指针
    
    p = max;    //函数指针初始化

    int ret = p(10, 15);    //函数指针的调用
    //int ret = (*max)(10,15);
    //int ret = (*p)(10,15);
    //以上两种写法与第一种写法是等价的，不过建议使用第一种方式
    printf("max = %d \n", ret);
    return 0;
}

函数类型: 是去掉指针P后的int (*) (int,int);

4.拓展分析

1.(* ( void (*）（）0）{}//调用0地址处的函数

机器硬件可以调用首地址为0位置的子例程。我们用软件不行，这里只是分析。

这串代码意思是调用0地址处的函数。
1.将0强制类型转换为void（*）（）类型的函数指针
2.在进行调用

六、 函数指针数组

1.函数指针数组的定义；

函数指针数组 的本质是一个数组，该数组用于存放函数指针。

2.使用

#include 
int add(int a, int b)
{
 return a + b;
}
int sub(int a, int b)
{
 return a - b;
}
int mul(int a, int b)
{
 return a*b;
}
int div(int a, int b)
{
 return a / b;
}
int main()
{
 int x, y;
 int input = 1;
 int ret = 0;
 int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
 while (input)
 {
 printf( "*************************\n" );
 printf( " 1:add 2:sub \n" );
 printf( " 3:mul 4:div \n" );
 printf( "*************************\n" );
 printf( "请选择：" );
 scanf( "%d", &input);
 if ((input <= 4 && input >= 1))
 {
 printf( "输入操作数：" );
 scanf( "%d %d", &x, &y);
 ret = (*p[input])(x, y);
 }
 else
 printf( "输入有误\n" );
 printf( "ret = %d\n", ret);
 }
 return 0;
}

由上面可以发现，使用函数指针数组，可以大大减少代码冗余度。

七、指向函数指针数组的指针

指向函数指针数组的指针 的本质是一个指针，指向函数指针数组。

八、函数回调

根据维基百科：回调函数是指 使用者自己定义一个函数，实现这个函数的程序内容，然后把这个函数（入口地址）作为参数传入别人（或系统）的函数中，由别人（或系统）的函数在运行时来调用的函数。函数是你实现的，但由别人（或系统）的函数在运行时通过参数传递的方式调用，这就是所谓的回调函数。简单来说，当发生某种事件时，系统或其他函数将会自动调用你定义的一段函数。

1.函数回调与函数指针关系

函数回调依赖于函数指针

2.为什么要回调

因为可以把调用者与被调用者分开。调用者不关心谁是被调用者，所有它需知道的，只是存在一个具有某种特定原型、某些限制条件（如返回值为int）的被调用函数。

如果想知道回调函数在实际中有什么作用，先假设有这样一种情况，我们要编写一个库，它提供了某些排序算法的实现，如冒泡排序、快速排序、归并排序等等，但为使库更加通用，不想在函数中嵌入排序逻辑，而让使用者来实现相应的逻辑；或者，想让库可用于多种数据类型（int、float、string），此时，该怎么办呢？可以使用函数指针，并进行回调。

回调可用于通知机制，例如，有时要在程序中设置一个计时器，每到一定时间，程序会得到相应的通知，但通知机制的实现者对我们的程序一无所知。而此时，就需有一个特定原型的函数指针，用这个指针来进行回调，来通知我们的程序事件已经发生。实际上，SetTimer()API使用了一个回调函数来通知计时器，而且，万一没有提供回调函数，它还会把一个消息发往程序的消息队列。

3.具体使用

#include 
void menu()
{
	printf("*************************\n");
	printf(" **********1:add 2:sub **\n");
	printf(" **********3:mul 4:div** \n");
	printf(" **********0:退出 *******\n");
	printf("*************************\n");
}
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
void Calc(int (*pf)(int, int))
{
	int input=0, x = 0, y = 0, ret = 0;
	printf("请输入两个操作数：");
	scanf("%d %d", &x,&y);
	ret = pf(x, y);
	printf("%d\n", ret);
}
int main()
{
	int x, y;
	int input = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Calc(add);
			break;
		case 2:
			Calc(sub);
			break;
		case 3:
			Calc(mul);
			break;
		case 4:
			Calc(div);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}