先看目录，看你知道多少
目录
1.字符指针
2.指针数组
3.数组指针
4.数组传参和指针传参
5.函数指针
6.函数指针数组
7.指向函数指针数组的指针
8.回调函数
什么是指针，我们在之前的《指针》章节已经接触过了，我们知道了指针的概念:
1.指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
2指针的大小是固定的4/8个字节（ 32位平台/64位平台)。
3.指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。
4.指针的运算。可以比较大小，如果两个指针指向同一数组，也可以相减，得到数的绝对值是之间的元素个数。
1.字符指针
在指针类型中，我们知道有一种指针类型为字符指针 char* ；
一般使用情况：
int main()
{
char ch = 'w';
char* pc = &ch;//pc就是字符指针，指向字符的指针就是字符指针
*pc = 'w';
return 0;
}
还有一种使用情况如下：存放常量字符串的首字符的地址
#include<stdio.h>
int main()
{
//下面右边是一个表达式，表达式的值是首字符的地址
char* p = "abcdef";//是把首字符的地址放到p中
//*p = 'w';//错误，这里字符串是常量字符串，不能修改
//const char *p = "abcdef";//这样写会更加严谨，
char arr[] = "abcdef"; //可以想象为字符串是arr,p是存放的arr的首元素地址
char* parr = arr; // p指向的是arr首元素地址，不同的是arr数组是可以修改
*parr='w';//可以修改arr字符串的值
printf("%s\n", arr);
return 0;
}
代码 char* p = "abcdef"; 特别容易让我们以为是把字符串 abcdef 放到字符指针 p 里了，但是/本质是把常量字符串 abcedf 首字符的地址放到了p中，也就是a的地址放到了指针变量p中。
看一下面这道题
#include <stdio.h>
int main()
{
char str1[] = "hello xilanhua";
char str2[] = "hello xilanhua";
const char* str3 = "hello xilanhua";
const char* str4 = "hello xilanhua";
if (str1 == str2)
{
printf("str1 和 str2 相等\n");
}
else
{
printf("str1 和 str2 不相等\n");
}
if (str3 == str4)
{
printf("str3 和 str4 相等\n");
}
else
{
printf("str3 和 str4 不相等\n");
}
return 0;
}str1 和str2 是两个字符数组的首元素地址，在内存中开辟不同的空间，所以str1和str2不相等，
str3 , str4 存放常量字符串 "hello xilanhua" 的首字符地址，常量字符串不能被修改，所以在内存中没有必要存两份，只需要开辟一份空间，两个指针都指向的这份空间，所以两个地址相同的。
所以输出结果为
2.指针数组
可以通过类比：
整型数组，存放整形的数组
字符数组，存放字符的数组
指针数组，存放指针的数组。
int* arr1[5];//整形指针数组
char* arr2[5];//一级字符指针的数组
char** arr3[5];//二级字符指针的数组
根据上面学的字符指针，我们看一下下面代码：
#include <stdio.h>
int main()
{
char* arr[] = { "abcdef","hehe","xilanhua" };//字符指针数组
// arr0 arr1 arr2 //这里存放的是常量字符串的首字符的地址
//*arr[1] = 'w';//错误，这里数组元素指向的也是常量字符串，不能修改
for (int i = 0; i < 3; i++)
{
printf("%s\n", arr[i]);
}
return 0;
}结果
看这段代码：
#include<stdio.h>
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 2,3,4,5,6 };
int arr3[] = { 3,4,5,6,7 };
//数组名是首元素地址
//arr是存放整形指针的数组 指针数组
int* arr[] = { arr1,arr2,arr3 };
int i = 0;
int j = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 5; j++)
{
printf("%d ", arr[i][j]);//和二维数组很像
//printf("%d ", *(arr[i] + j));
//*(arr[i]+j)==arr[i][j] arr[i]==*(arr+i)
}
printf("\n");
}
return 0;
}结果：
可以发现和二维数组很像，但是本质上是不同的，二维数组是连续存放的空间，但是这里不是，是通过指针联系起来的。
3.数组指针
也是通过类比：
整形指针，指向整形的指针变量
字符指针，指向字符的指针变量
数组指针，指向数组的指针变量
下面哪一个是数组指针？
int* p1[10];
int (*p2)[10];
解释：
int (*p)[10]
p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
这里要注意:[ ] 的优先级要高于*号的，所以必须加上(）来保证p先和*结合。不加（），就是指针数组。
1. &数组名 和 数组名
看下面代码：
#include<stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);//数组名是首元素地址 两个例外 &数组名和sizeof(数组名)
printf("%p\n", &arr[0]);//首元素地址
printf("%p\n", &arr); //三个数值上相等
printf("%p\n", arr + 1);//int* + 1
printf("%p\n", &arr[0] + 1);//int* + 1
printf("%p\n", &arr + 1);//加了40 int(*)[10]+1
int(*p)[10] = &arr;
//int(*)[10] 这个数组指针的类型
return 0;
}
根据上面的代码我们发现，其实&ar r和 arr，虽然值上是相同的，但是意义是不相同的。实际上:&arr表示的是数组的地址，而不是数组首元素的地址。（细细体会一下)。数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于&arr 的差值是40.
总结：
数组名是首元素地址 有两个例外 &数组名 和 sizeof(数组名)
1.sizeof(arr) - sizeof内部单独放一个数组名的时候，数组名表示整个数组，计算得到的是数组的大小
2.&arr - 这里的数组名表示的是整个数组，取出的是整个数组的地址，从地址值的角度来讲和数组的首元素地址是一样的，但是意义不一样
2.访问数组元素的不同方式
#include<stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
//下标形式访问数组
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
//使用指针访问数组
int* p = arr;
for (i = 0; i < sz; i++)
{
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));
}
}
//数组指针访问数组 虽然对，但是不推荐
int(*pa)[10] = &arr;
//pa == &arr
//*pa == *&arr
//*pa == arr 数组名 不是两种特殊情况 是首元素地址
for (i = 0; i < sz; i++)
{
printf("%d ", *((*pa)+i));//(*pa)[i];
}
return 0;
}
注意：
int(*pa)[10] = &arr;
//pa == &arr
//*pa == *&arr
//*pa == arr 数组名 不是两种特殊情况 是首元素地址所以：数组指针 解引用 是数组首元素地址
3. 数组指针的使用
二维数组的传参要使用到指针数组。
#include<stdio.h>
//普通接收二维数组传参形式
void print1(int arr[3][5], int r, int c)
{
int i = 0;
int j = 0;
for (i = 0; i < r; i++)
{
for (j = 0; j < c; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
//二维数组传参用到数组指针
void print(int (*arr)[5], int r, int c)//指针形式接受 数组指针
{
int i = 0;
int j = 0;
for (i = 0; i < r; i++)//arr+i是每一行 *(arr+i)是每一行的数组名 arr[i] 首元素地址就是每一行的第一个元素的地址
{
for (j = 0; j < c; j++)
{
//printf("%d ", *(*(arr + i) + j));//解引用数组指针就是数组首元素地址，二维数组是第一行地址
printf("%d ", arr[i][j]);//*(*(arr+i)+j)==*(arr+i)[j]==arr[i][j]
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
print(arr, 3, 5);//二维数组的数组名，也表示首元素地址
//二维数组的首元素地址是第一行的地址，存放的是一维数组
//可以理解为二维数组是存放一维数组的数组
return 0;
}二维数组的数组名，也表示首元素地址。二维数组的首元素地址是第一行的地址，存放的是一维数组。可以理解为二维数组是存放一维数组的数组
4.数组传参和指针传参
在写代码的时候难免要把【数组】或者【指针】传递给函数，那函数的参数该如何设计呢？
一维数组传参：
形参可以是数组，也可以是指针，当形参是指针时，要注意类型。
#include<stdio.h>
void test(int arr[])//不会真的创建一个数组，不写大小
{}
void test(int arr[10])//和传入格式一样，不会真的创建
{}
void test(int* arr)//数组名，首元素地址，指针接受
{}
void test2(int* arr[20])//指针数组，和传入格式一样
{}
void test2(int** arr )//数组首元素是int* 类型，*arr说明他是指针
{}
int main()
{
int arr[10] = { 0 };//整形数组
int* arr2[20] = { 0 };//整形指针数组
test(arr);
test2(arr2);
return 0;
}二维数组传参：
参数可以是指针，也可以是数组，如果是数组，行可以省略，列不能省略，如果是指针，传参传过去的是第一行的指针，形参就应该是数组指针
void test(int arr[3][5])
{}
//void test(int arr[][])//错误，只能省略行，因为得知道一行有几个元素
//{}
void test(int arr[][5])
{}
//void test(int *arr)//错误，二维数组的首元素地址是第一行的地址
//{}
//void test(int* arr[5])//错误，这是一个指针数组，存放整形指针的数组
//{}
void test(int(*arr)[5])//数组指针，可以接收实参
{}
//void test(int** arr)//错误，二级指针
//{}
int main()
{
int arr[3][5] = { 0 };
test(arr);
return 0;
}一级指针传参：
#include<stdio.h>
void print(int* p, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d\n", *(p + i));//通过指针访问
}
}
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;//一级指针
int sz = sizeof(arr) / sizeof(arr[0]);//元素个数
print(p, sz);
return 0;
}思考：当一个函数参数是一个指针时，函数能接收什么参数
void print(int* p);
1.int a;
print(&a);//变量的地址
2.int* p=&a;
print(p);//指针变量
3.int arr[10];
print(arr);//数组名
二级指针传参：
#include<stdio.h>
//用二级指针接收
void test(int** ptr)
{
printf("num = %d\n", **ptr);
}
int main()
{
int n = 10;
int* p = &n;
int** pp = &p;
test(pp);
test(&p);
return 0;
}思考：当函数的参数为二级指针的时候，可以接收什么参数
1.一级指针的地址
2.二级指针变量，
3.指针数组
5.函数指针
这里还是类比：
整形指针，指向整形的指针 int*
字符指针，指向字符的指针 char*
数组指针，指向数组的指针，int arr[10]; int (*p)[10] = &arr;
函数指针，指向函数的指针， 即存放函数的地址
那么问题来了，函数有地址吗
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
//&函数名得到就是函数的地址
int main()
{
printf("%p\n", &Add);//可以运行
printf("%p\n", Add);//可以运行
return 0;
}
//函数名 和 &函数名都是函数的地址结果：
可以得出结论，函数名 和 &函数名 都是函数的地址。
使用函数指针调用函数:
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
//()是pf先于*结合，说明pf是指针
int (*pf)(int, int) = Add;//函数的地址要存起来，就得放在 函数指针变量pf 中
//最前面的是函数返回类型，后面括号内是函数参数类型
//通过函数指针调用函数
int ret = (*pf)(3, 5);
ret = Add(3, 5);//函数可以这样调用，Add是地址
ret = pf(3, 5);//所以这样写也对
ret = (*****pf)(3, 5);//编译器在处理时，会把*去掉，也没有问题
printf("%d\n", ret);//8
return 0;
}可以阅读两段有趣的代码
1.(*(void(*)( ))0)( );
#include<stdio.h>
int main()
{
//1.将0强制类型转换为void(*)()类型的函数指针
//2.这就意味着0地址处放着一个函数，函数无参，返回类型是void
//3.调用0地址处的这个函数
(*(void(*)())0)();//前面*可以不写
return 0;
}2.void(* signal(int, void(*)(int) ) )(int);
int main()
{
void(* signal(int, void(*)(int) ) )(int);
//signal先于（）结合
//void(*)(int)
//signal(int, void(*)(int));//函数名称和函数参数类型
//上述代码是一个函数的声明，
//函数的名字是signal
//函数的参数第一个是int类型，第二个是void(*)(int)类型的函数指针
//该函数指针指向的函数参数是int,返回类型是void
//signal函数的返回类型也是一个函数指针
//该函数指针指向的函数参数是int,返回类型是void
return 0;
}
可以通过类型重命名简化为：
//typedef int(*)(int) pt_f;//写法不对
typedef void(*pf_t)(int);//将void(*)(int)类型的函数指针重命名叫pf_t
pf_t(signal(int, pf_t));
6.函数指针数组
存放函数指针的数组
函数指针数组写法
函数指针
int (*p)(int,int);
函数指针数组只需在p后加一个[大小]，让指p先于[]结合
int (*p[10])(int,int);
//数组存放元素的类型就是 int (*) （int,int)函数指针数组的用途：转移表
例子：（计算器）
#include<stdio.h>
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("************************\n");
printf("**** 1.add 2.sub ****\n");
printf("**** 3.mul 4.div ****\n");
printf("**** 0.exit ****\n");
}
int main()
{
//转移表 - 函数指针数组 函数指针类型要相同
int(*pfArr[5])(int, int) = { NULL,Add,Sub,Mul,Div };//NULL==0
// 下标 0 1 2 3 4
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
do
{
menu();
printf("请输入:> ");
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
break;
}
if (input <= 4 && input >= 1)
{
printf("请输入两个操作数:>");
scanf("%d %d", &x, &y);
printf("%d\n",pfArr[input](x, y));//调用相应的计算函数
}
else
{
printf("输入非法，请重新输入\n");
}
} while (input);
return 0;
}7.指向函数指针数组的指针
指向函数指针数组的指针是一个指针，指针指向一个数组，数组的元素都是函数指针。
示例：
#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int main()
{
//函数指针
int(*pf)(int, int) = Add;
//函数指针数组
int(*pfArr[4])(int, int) = { Add,Sub };
//ppfArr是一个指向一个函数指针数组的指针变量
int(*(*ppfArr)[4])(int,int) = &pfArr;
return 0;
}8.回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址)作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
这里演示一个用到回调函数的库函数，qsort 函数，包含头文件 stdlib.h 。
我们通过c++官方网站旧版上可以查到 qsort 函数的用法qsort用法
先看返回值类型和参数列表
它可以排序任何类型的数据，但是需要自己写一个函数用来可以确定两个元素的大小，也就是参数列表中的compar函数。
void qsort( void* base,//待排序数组的第一个元素
size_t num, //待排序的元素个数
size_t size, //每个元素的大小
int(*cmp)(const void*, const void*));//函数指针，指向一个函数，这个函数可以比较2个元素的大小qsort 函数底层使用的是快速排序，也是一种排序算法，我们这里用冒泡排序实现一下。
因为这个函数可以排序任何类型，所以我们最开始用 void * 指针来接收传来的指针，然后再通过强制类型转换 （char*) 再加上 size 来确定操作空间的大小。
我们先来实现以下cmp 函数
这是cmp函数的要求，返回值有大于0，小于0，和等于0，三种情况。 大于0指向p1，p1大，小于0指向p2，p2大,相等返回值是0。
int cmp_int(const void* p1, const void* p2)
{
return *(int*)p1 - *(int*)p2;
//这是我们自己写的函数，我们知道是int类型，所以强制类型转换为(int*)
}交换函数：
因为我们不知道要交换什么类型元素，所以是使用 (char*) 强制类型转换，每次交换一个字节，循环size次的方法
void Swap(char* p1, char* p2, size_t size)
{
for (size_t i = 0; i < size; i++)
{
char t = *(p1 + i);
*(p1 + i) = *(p2 + i);
*(p2 + i) = t;
}
}排序内部：
void bubble_sort(void* base, size_t num, size_t size, int(*cmp)(const void*, const void*))
{
size_t i = 0;
size_t j = 0;
for (i = 0; i < num - 1; i++)//一趟冒泡排序
{
for (j = 0; j < num - 1 - i; j++)
{
//两个相邻元素比较
//arr[j]与arr[j+1] 调用我们自己写的比较函数，回调函数
if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
{
//交换
Swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
}
}
}
全部代码：
#include<stdio.h>
#include<stdlib.h>
int cmp_int(const void* p1, const void* p2)
{
return *(int*)p1 - *(int*)p2;
//这是我们自己写的函数，我们知道是int类型，所以强制类型转换为(int*)
}
void Swap(char* p1, char* p2, size_t size)
{
for (size_t i = 0; i < size; i++)
{
char t = *(p1 + i);
*(p1 + i) = *(p2 + i);
*(p2 + i) = t;
}
}
void bubble_sort(void* base, size_t num, size_t size, int(*cmp)(const void*, const void*))
{
size_t i = 0;
size_t j = 0;
for (i = 0; i < num - 1; i++)//一趟冒泡排序
{
for (j = 0; j < num - 1 - i; j++)
{
//两个相邻元素比较
//arr[j]与arr[j+1]
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[10] = { 1,2,8,9,10,5,3,6,4,7 };
qsort(arr, 10, sizeof(arr[0]), cmp_int);
for(int i=0;i<10;i++)
{
printf("%d ", arr[i]);
}
printf("\n");
int arr1[10] = { 1,2,8,9,10,5,3,6,4,7 };
bubble_sort(arr1, 10, sizeof(arr[0]), cmp_int);
for (int i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
return 0;
}本篇结束
