指针数组、数组指针、函数指针、函数指针数组、指向函数指针数组的指针、回调函数

指针数组与数组指针

指针数组：指针数组就是存放指针的数组，其本质为数组。
数组指针：数组指针是指向数组的指针，其本质为指针指向的对象是数组。
由于“[ ]”的优先级高于“ * ”的优先级，指针数组与数组指针的表达可做如下表示：

int * p1 [10];  // 指针数组  p1先与“[ ]”结合构成一个包含10个元素的数组，int表示的则是数组的内容。
int ( p2)[10];  // 数组指针  p2先与“ * ”构成指针定义，int表示数组内容，[10]表示数组内元素个数。

解释：
int（*p)[10]

p先和结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
这里要注意：[ ]的优先级要高于号的，所以必须加上（）来保证p先和*结合。

&数组名vs数组名
对于下面的数组：

int arr[10]；

arr和&arr分别是啥？
我们知道arr是数组名，数组名表示首元素的地址
那&arr数组名是啥呢？
我们先看一段代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", &arr);
	system("pause");
	return 0;
}

运行结果：

可见数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再看一段代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
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);
	system("pause");
	return 0;
}

根据上面的代码我们发现，其实&arr和arr，虽然只是一样的，但是意义应该是不一样的。
实际上：&arr表示的是数组的地址，而不是数组首元素的地址。数组的地址+1，跳过整个数组的大小，所以&arr+1相对于&arr的差值是40（对指针加1，是加上指针所指向类型的大小，二级指针往上都是指针，每加1整个数组加4）

**总结：对于数组指针最重要的是要理解其本质是指针，而且其偏移量受到自身指向的数组大小影响即可。相较之下，指针数组就很好理解了，不过是本质是数组且每个数组元素是指针罢了（不管是指向何种类型的指针在32位平台下其自身的空间占用量都是4个字节）。

函数指针

知道了数组指针是指向数组的指针，那么同理也可以对函数指针进行相同的理解，函数指针就是指向函数的指针了。
  函数在内存中占用一块地址而且这块地址也是可以赋给一个指针变量的，也就是说可以通过这个地址访问到这个函数。与数组相似，函数名也是指向函数第一条指令的常量指针。所以说函数的调用可以通过函数名，也可以通过指向函数的指针来调用。
  
  函数指针表现形式：**type (*func)(type &,type &)**该语句声明了一个指针func，它指向了一个函数，这个函数带有了2个type型参数并返回一个type的值。
  需要特别注意的是第一个括号一定要写，如果不写的话表达式就变成了函数声明而非函数指针。
  分析以下两句代码，看看是什么意思：

1.(*(void (*)())0)();
2.void(*signal(int,void(*)(int)))(int);

表达式1：

表达式2：

函数指针数组

在对函数指针有了一定的了解之后，函数指针数组就很好理解了，其意义就是定义一个数组，数组的内容均是指向函数的指针。
表达式：

int (*arr1[10])(); 

arr1先于[]结合，表明其本质是数组，其指向的类型是int (*)()返回值为int的函数。即函数指针数组。

函数指针数组的用途：转移表 例子：（计算器）

#include<stdio.h>
#include<stdlib.h>
#pragma warning(disable:4996)
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;
	while (input)
	{
		printf("******************************\n");
		printf("****** 1:Add      2:Sub ******\n");
		printf("****** 3:Mul      4:Div ******\n");
		printf("******************************\n");
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入操作数：");
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			break;
		case 2:
			printf("请输入操作数：");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			break;
		case 3:
			printf("请输入操作数：");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			break;
		case 4:
			printf("请输入操作数：");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			break;
		default:
			printf("输入错误\n");
			break;
		}
		printf("ret = %d\n", ret);
	}
	system("pause");
	return 0;
}

指向函数指针数组的指针

当定义了一个函数指针数组后，能否在定义一个指针用于保存这个数组的地址呢？这个指针就是指向函数指针数组的指针。其表达式为：

void (*(*p)[5]) )(void) 

表示 一个指向有5个元素每个元素为指向一个返回值为空的函数的数组的指针。

回调函数

回调函数就是通过一个函数指针调用的函数。如果把函数的指针（地址）作为一个参数传递给另一个函数，当这个函数被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方式直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

首先演示一下qsort函数的使用：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>

//qsort函数的使用者得实现一个比较函数
int int_cmp(const void*p1, const void*p2)
{
	return (*(int *)p1 > *(int *)p2);
}
int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 3, 7, 9, 8, 0 };
	int i = 0;

	qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d", arr[i]);
	}
	printf("\n");
	system("pause");
	return 0;
}

使用回调函数，模拟实现qsort（采用冒泡的方式）

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int int_cmp(const void*p1, const void*p2)
{
	return (*(int *)p1 > *(int *)p2);
}
void _swap(void*p1, void*p2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *((char *)p1 + i);
		*((char *)p1 + i) = *((char *)p2 + i);
		*((char *)p2 + i) = tmp;
	}
}
void bubble(void *base, int count, int size, int(*cmp)(void *, void *))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < count - 1; i++)
	{
		for (j = 0; j < count - i; j++)
		{
			if (cmp((char *)base + j*size, (char *)base + (j + 1)*size)>0)
			{
				_swap((char *)base + j*size, (char *)base + (j + 1)*size, size);
			}

		}
	}
}
int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 3, 7, 9, 8, 0 };
//	char*arr[]={"aaaa","bbbb","cccc","dddd"};
	int i = 0;

	bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d", arr[i]);
	}
	printf("\n");
	system("pause");
	return 0;
}