目录
本关boss
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 = 'w';
printf("%c\n", *p);
return 0;
}
int main()
{
const char* pstr = "hello world.";//这里pstr指向 hello world 的首字符地址
printf("%s\n", pstr);
return 0;
}
那就有可这样的面试题：
int main()
{
char str1[] = "hello world";
char str2[] = "hello world";
const char* str3 = "hello world";
const char* str4 = "hello world";
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;
}打印出的结果：
str1 and str2 are not same
str3 and str4 are same
因为这里比较的是地址
str3 和 str4 是const修饰的，没人可以去改它，所以他两个存了相同的一份地址
str1 和 str2 是两份独立的数组空间，所以不一样
如果要比较字符串额内容用：strcmp函数
2. 指针数组
int* arr1[10]; //整形指针的数组
char* arr2[4]; //一级字符指针的数组
char** arr3[5];//二级字符指针的数组
int main()
{
const char* a[5] = {"abcdef", "zhangsan", "hehe", "wangcai", "ruhua"};
//存放指针的数组 - 指针数组，
//a[5]数组里面存放的是每个字符串首字符的地址
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%s\n", a[i]);
}
int arr1[5] = { 1,2,3,4,5 };
int arr2[5] = { 2,3,4,5,6 };
int arr3[5] = { 3,4,5,6,7 };
int* arr[3] = {arr1, arr2, arr3};
//arr也是一个指针数组，利用指针数组实现二维数组
int i = 0;
int j = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 5; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
return 0；
}3.数组指针
3.1 数组指针的定义
int main()
{
int a = 10;
int* p1 = &a;
//整型指针 - 指向整型的指针 - 存放整型变量的地址
char ch = 'w';
char* p2 = &ch;
//字符指针 - 指向字符的指针 - 存放字符变量的地址
int arr[10] = {1,2,3,4,5};
int *pa[10] = &arr;//err，因为pa会先和[10]结合
int (* pa)[10] = &arr;
//取出的是数组的地址存放到pa中，pa是数组指针变量
//int(* )[10] -> 数组指针类型
//数组指针 - 指向数组的指针 - 存放的是数组的地址
return 0;
}3.2 &数组名VS数组名
int main()
{
int arr[10] = {0};
printf("%p\n", arr);
printf("%p\n", arr+1);
printf("%p\n", &arr[0]);
printf("%p\n", &arr[0]+1);
printf("%p\n", &arr);
printf("%p\n", &arr+1);
return 0;
}
可以看出，arr+1 相较于 arr 跳过了4个字节的大小，
而 &arr+1 相较于 &arr 跳过了40（10*4）个字节，一个数组的地址
因为&arr 指向的是一整个数组
大多数情况下数组名是数组首元素的地址，但是有两个例外：
1. sizeof(数组名)
2. &数组名
3.3 数组指针的使用
数组指针指向的是数组，
那数组指针中存放的应该是数组的地址。
其多用于二维数组中
void print4(int (*p)[5], int r, int c)
{
int i = 0;
for (i = 0;i < r;i++)
{
int j = 0;
for (j = 0;j < c;j++)
{
printf("%d ", *(*(p + i) + j));//=>p[i]
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
print4(arr, 3, 5);
return 0;
}arr这个二维数组中存放：
【1，2，3，4，5】
【2，3，4，5，6】
【3，4，5，6，7】
在一维数组中 arr 传的是首元素地址
在二维数组中首元素地址就是 二维数组的第一行的地址
这时，arr传的就是第一行的地址，及【1，2，3，4，5】的地址所以我们用 (*p)[5] 来进行的接受，
学了指针数组和数组指针我们来一起回顾并看看下面代码的意思：
int arr[5];——整形数组
int *parr1[10];——指针数组
int (*parr2)[10];——数组指针
int (*parr3[10])[5];
对于这个，们应该拆开来看，首先 parr3[10] 这是一个数组，
剩下的 （* )[5] 是一个数组指针类型，
所以 parr3是存放【数组指针】的数组
4. 数组参数、指针参数
4.1 一维数组传参
void test(int arr[])
{}
void test(int arr[10])
{}
//形参是数组的形式
void test(int* arr)
{}
//数组传参，形参是指针的形式（因为数组传参传的是首元素地址）
void test2(int* arr[20])
{}
//这也是可以的，这里面的20也可以省略
void test2(int** arr)
{}
//这也是可疑的，因为arr2的是一个指针数组，里面存放的是地址
//在传参的时候又传的是首元素地址，传的是地址的地址，也就是二级指针
//所以可以用二级指针去接收
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
test2(arr2);
}4.2 二维数组传参
void test(int arr[3][5])//ok
{}
void test(int arr[][])//err 不能行和列全部省略
{}
void test(int arr[][5])//ok
{}
//形参用数组形式接受，需注意行必须和要接受的数组一样
void test(int* arr)//err
{}
//二维数组传递的是一行的地址，所以这肯定是不行的
void test(int* arr[5])//err
{}
//传来的地址需要指针接受，而现在的arr[5]本质是数组，所以不行
void test(int(*arr)[5])//ok
{}
//这是数组指针，用来存放数组地址的指针，ok
void test(int** arr)//err
{}
//我们传的是一行的地址，是一维数组的地址，
//二级指针是用来接收一级指针变量的地址的
int main()
{
int arr[3][5] = { 0 };
test(arr);
}总结：
二维数组传参，函数形参的设计只能省略第一个[]的数字。
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
这样才方便运算。
4.3 一级指针传参
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 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
//一级指针p，传给函数
print(p, sz);
return 0;
}当一个函数的参数部分为一级指针的时候，函数能接收什么参数？
void test (int* p)
1. 可以传地址
int a = 0;
test(&a);
2.可以传指针变量
int* ptr=&a;
test(ptr);
3.可以传数组首元素地址
int arr[10];
test(arr);
4.4 二级指针传参
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;
}当函数的参数为二级指针的时候，可以接收什么参数？
void test(int** p)
{}
1.
int** ptr;
test(ptr);
2.对一级指针取地址，传给二级指针接受
int* p2 = ;
test(&p2);
3. 传指针数组的数组名
int*arr[10]
test(arr)
5. 函数指针
就是指向函数的指针
首先看一段代码：
int add(int x,int y)
{
return x + y;
}
int main()
{
printf("%p\n", add);
printf("%p\n", &add);
//注意这里，add 和 &add 是一样的，都是取函数的地址
//1.pf = &add;
//2.(*pf)() = &add;//说明* pf是个函数,函数指向add
//3.int (*pf)(int x, int y) = add;//函数的参数是（int x,int y），返回类型是int
int (*pf)(int x, int y) = add;
int sum = (*pf)(3, 5);
//pf就是函数指针变量
printf("%d\n", sum);
//int sum = add(3, 5);
//int sum = pf(3, 5);像上面函数这样写也是ok的，
//语法上来说，*可以去掉，我们加上*用来帮助理解
return 0;
}分下下面两段代码
代码1：
(*(void (*)())0)();void (*)()——函数指针类型
( 类型 )——强制类型转换
(void (*)())0 —— 把0强制转化为一个函数的地址
(*(void (*)())0)();——解引用0地址的函数，并调用
代码2：
void (*signal(int , void(*)(int)))(int);signal ( int , void ( * )( int ) )——signal是函数名，
第一个参数是int，第二个参数是一个函数指针剩下void（ * ）（ int ）——说明signal的返回类型也是一个函数指针类型
上述代码是一次函数声明
// 声明的函数叫：signal
// signal函数的第一个参数是int类型的
// signal函数的第二个参数是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void
// signal函数的返回类型也是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void
// void (*)(int) signal(int, void(*)(int)); //err上述简化是错的，可以用 typedef 函数进行简化
typedef void （*pf_t）（int） ;
pf_t signal( int, pf_t);
函数指针也是一种类型
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*pf)(int, int) = Add;
//函数指针（*pf）指向的参数是：int，int，返回类型也是int,存放add函数的地址
//int (*)(int, int)——函数指针类型
//把函数指针名称去掉，留下的就是函数指针类型
return 0;
}6. 函数指针数组
写法：int (*parr[10]) ( int，int，... );
int 函数返回类型，parr指针数组名称，
*parr[10]，指针数组类型，注意：parr会首先和 [ ] 结合，然后和 * 结合
函数参数是 int，int...
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int main()
{
//函数指针数组
//可以存放多个【参数相同、返回类型相同】的函数的地址
int (* pfArr[2])(int, int) = {Add, Sub};
//访问：
int ret = pfArr[0](2, 3);
printf("%d\n", ret);
ret = pfArr[1](2, 3);
printf("%d\n", ret);
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("***************************\n");
printf("***** 1.add 2. sub ****\n");
printf("***** 3.mul 4. div ****\n");
printf("***** 0.exit ****\n");
printf("***************************\n");
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入2个操作数:>");
scanf("%d %d", &x, &y);
ret = Add(x, y);
printf("%d\n", ret);
break;
case 2:
printf("请输入2个操作数:>");
scanf("%d %d", &x, &y);
ret = Sub(x, y);
printf("%d\n", ret);
break;
case 3:
printf("请输入2个操作数:>");
scanf("%d %d", &x, &y);
ret = Mul(x, y);
printf("%d\n", ret);
break;
case 4:
printf("请输入2个操作数:>");
scanf("%d %d", &x, &y);
ret = Div(x, y);
printf("%d\n", ret);
break;
case 0:
printf("退出计算器\n");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
}可以发现此时代码在用 switch 语句时，非常繁杂冗余，
我们可以用函数指针数组做简化：
//这里省略各种函数，可参考上述代码
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
//函数指针数组 - 转移表
int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
break;
}
if (input >= 1 && input <= 4)
{
printf("请输入2个操作数:>");
scanf("%d %d", &x, &y);
ret = pfArr[input](x, y);
printf("%d\n", ret);
}
else
{
printf("选择错误\n");
}
} while (input);
}这种函数指针数组 我们经常称为 转移表
7. 指向函数指针数组的指针
函数指针：
int ( *pf ) ( int , int );
函数指针数值：
int ( *pfarr[ 10 ] ) ( int , int );
指向函数指针数组的指针:
int ( * (*ptr)[10] ) ( int , int ) = &pfarr;
暂时能认识就行
8. 回调函数
回调函数就是一个通过函数指针调用的函数。
如果你把函数的指针（地址）作为参数传递给另一个 函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进 行响应。
这里还是拿上述计算器的代码来举例。
//这里省略各类计算函数，可参考上面的代码
void calc(int (*p)(int, int))
{
int x = 0;
int y = 0;
int ret = 0;
printf("请输入2个操作数:>");
scanf("%d %d", &x, &y);
ret = p(x, y);
printf("%d\n", ret);
}
int main()
{
int input = 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);当calc函数传送的是Add函数的地址，这是p调用的是Add函数，这是我们称Add为回调函数
这里并不是直接调用各种计算函数，而是把计算函数函数的地址，传递给了calc函数
再由calc函数指针 int (*p)(int, int) 之后，在适当位置通过函数指针 p 调用它所指向的函数
这个机制就称为回调函数
8.1qsort 函数：
首先什么式qsort函数：
（qsort——C语言标准库提供的排序函数，其用的是快速排序的思想）
在这之前，我们先来回顾一下经典的冒泡排序
void bubble_sort(int *arr, int s)
{
int i = 0;
int j = 0;
for (j = 0;j < s-1;j++)
{
for (i = 0;i < s-1-j;i++)
{
if (arr[i] > arr[i + 1])
{
int temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
}
}
void print(int* arr, int s)
{
int i = 0;
for (i = 0;i < s;i++)
{
printf("%d", arr[i]);
}
printf("\n");
}
int main()
{
//冒泡排序
//对整型数据进行排序 - 排序为升序
int arr[] = { 2,1,3,7,5,9,6,8,0,4 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz);
print(arr, sz);
return 0;
}冒泡排序他相比于qsort来说，它的排序功能较小，比如上述的冒泡排序，只能排int类型的数据
但对于qsort来说，它可以排任意类型的数据
qsort 怎么用：
void qsort(void* base,size_t num,size_t size,int (*cmpar)(const void*, const void*));
先来看qsort的参数部分
void* base, //待排序数据的起始地址
size_t num, //待排序数据的元素个数
size_t size, //待排序数据元素的大小（单位是字节）
int (*cmpar)(const void*, const void*) //比较2个元素大小的函数指针
void*的指针式非常宽容的，可以接受任意类型的地址
int i = 20;
void* p；
p=&i;
但要注意在解引用的时候：
1.*p=200; // err,void*的指针不能直接解引用，需要进行强制类型转换
*(int* )p=200;
2.p++//也不行，还是需要先行强制类型转换
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Stu
{
char name[20];
int age;
};
//比较名字
//用strcmp（字符串比较大小的函数）需引用<string.h>
int cmp_stu_by_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
//比较年龄
int cmp_stu_by_age(const char* e1,const char* e2)
{
return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
//测试qsort排序结构体数据
void test3()
{
struct Stu s[] = { {"zhangsan", 20}, {"lisi", 55}, {"wangwu", 40} };
int sz = sizeof(s) / sizeof(s[0]);
//qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}
int main()
{
test3();
return 0;
}下面式比较年龄的排序结果：
比较前：
比较后：
8.2 用冒泡函数的思想实现 qsort 函数：
int cmp_int(const void* e1, const void* e2)
{
return (*(int*)e1 - *(int*)e2);
}
void Swap(char* buf1, char* buf2, int width)
{
int i = 0;
for (i = 0; i < width; i++)
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
//用bubble_sort2来实现qsort函数
void bubble_sort2(void* base, int sz, int width, int (*cmp)(const void* e1, const void* e2))
{
int i = 0;
//趟数
for (i = 0; i < sz - 1; i++)
{
//一趟冒泡排序的过程
int j = 0;
for (j = 0; j < sz - 1 - i; j++)
{
if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
{
//交换
Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
}
}
}
}
void test4()
{
int arr[] = { 2,1,3,7,5,9,6,8,0,4 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort2(arr, sz, sizeof(arr[0]), cmp_int);
print(arr, sz);
}
void print(int* arr, int s)
{
int i = 0;
for (i = 0;i < s;i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
int main()
{
test4();
return 0;
}