一、回调函数

      函数指针是将函数的地址取出来，再通过函数地址去调用，那为什么不直接用函数名调用呢？？原因是因为函数指针可以用来实现回调函数，而回调函数有自己的应用场景。

      回调函数就是⼀个通过函数指针调⽤的函数。 如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数 时，被调⽤的函数就是回调函数。

<code>#include <stdio.h>

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;

do

{

printf("*************************\n");

printf(" 1:add 2:sub \n");

printf(" 3:mul 4:div \n");

printf(" 0:exit \n");

printf("*************************\n");

printf("请选择：");

scanf("%d", &input);

switch (input)

{

case 1:

printf("输⼊操作数：");

scanf("%d %d", &x, &y);

ret = add(x, y);

printf("ret = %d\n", ret);

break;

case 2:

printf("输⼊操作数：");

scanf("%d %d", &x, &y);

ret = sub(x, y);

printf("ret = %d\n", ret);

break;

case 3:

printf("输⼊操作数：");

scanf("%d %d", &x, &y);

ret = mul(x, y);

printf("ret = %d\n", ret);

break;

case 4:

printf("输⼊操作数：");

scanf("%d %d", &x, &y);

ret = div(x, y);

printf("ret = %d\n", ret);

break;

case 0:

printf("退出程序\n");

break;

default:

printf("选择错误\n");

break;

}

} while (input);

return 0;

}

      以上这段代码中，我们发现case部分的代码总是重复出现，这段代码只有调用函数的逻辑有差异（但是函数的返回类型和形参是一样的），其他输入输出操作都是冗余的，那么这个时候我们可以把调用的函数地址以参数的形式传去，用函数指针接收，函数指针指向什么函数就调用什么函数，这里其实就是使用的回调函数功能。

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 ret = 0;

int x, y;

printf("输入操作数：");

scanf("%d %d", &x, &y);

ret = pf(x, y);

printf("ret = %d\n", ret);

}

int main()

{

int input = 1;

do

{

printf("*************************\n");

printf(" 1:add 2:sub \n");

printf(" 3:mul 4:div \n");

printf(" 0:exit \n");

printf("*************************\n");

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;

}

       回调函数不是由该函数的实现方直接调⽤，⽽是在特定的事件或条 件发⽣时由另外的⼀⽅调⽤的，⽤于对该事件或条件进⾏响应。

      怎么理解上面这段话呢？我们可以发现回调函数并非直接调用的，而是当需要进行某种运算时（特定需求的发生），根据需求将函数地址传给pf，然后在calc（另外一方）函数中通过pf（间接调用）来调用这个函数。

二、qsort使用举例

前面学习的冒泡排序，只能排序整形数据，那我们如何完成其他数据的排序呢？就得用到qsort

qsort是一个库函数，可以完成任意数据的排序，我们首先通过cplusplus的网站来了解qsort，qsort的头文件是stdlib.h，下面我们能来分析他的形参类型。

1.第一个形参void*base是一个void*类型的指针（因为该数组可能是任意类型，所以只有void*才可以接收任意类型的数据的地址），base指向要排序的数组的第一个元素位置。

2.第二个形参size_t num是一个无符号整型，num指向的是待排序数组中的元素个数。（只要知道元素的个数才能确定比较的次数。）

3.第三个形参size_t size是一个无符号整型，size指向数组中元素的大小（单位是字节，因为qsort完成任何类型的排列，所以对象可能是结构体也可能是整型，需要具体传入去 运算）。

4.第四个形参int (*compar)(const void*,const void*));，compar是一个函数指针，返回类型是int类型，两个形参的类型是void*类型。该函数指针指向的函数是用来比较数组中两个元素的方法。这个方法是根据我们的需求（比较整型或者比较结构体数据），去构造一个函数用来比较，构造的函数返回类型和形参类型必须一致。

qsort通过返回值来判断p1和p2的大小，当返回值>0,说明p1大于p2，返回值=0，说明p1=p2，返回值<0,说明p1＜p2。

了解了qsort，下面利用qsort来实现排序。

2.1 使用qsort排序整型数据

<code>int int_cmp(const void* p1, const void* p2)//整型的比较方法

{

return(*(int*)p1 - *(int*)p2);//void*类型的指针必须强转后才可以进行运算。

}

int main()

{

int arr[] = { 9,8,7,6,5,4,0,2,1,3 };

int num = sizeof(arr) / sizeof(arr[0]);//确定数组的个数

int size = sizeof(int);//确定数组的每个元素占用字节大小

qsort(arr, num, size, int_cmp);

for (int i = 0; i < num; i++)

{

printf("%d ", arr[i]);

}

printf("\n");

return 0;

}

运行结果：0 1 2 3 4 5 6 7 8 9  

注意事项：

1.qsort的使用必须包含头文件stdlib.h

2创建比较方法int_cmp函数时要注意该函数返回的结果必须是>0,=0,<0;

3.int_cmp传入的是void*类型的指针，必须强转成int*类型再解引用才可以进行运算。

4.如果想要完成逆序，将int_cmp的代码return(*(int*)p1 - *(int*)p2)中的p1和p2交换即可。

2.2 使用qsort排序结构体数据

struct Stu//学生

{

char name[20];//名字

int age;//年龄

};

//创建用年龄比较的方法

int cmp_stu_by_age(const void* p1, const void* p2)

{

return((struct Stu*)p1)->age - ((struct Stu*)p2)->age;//也可以写成（*（struct stu*）p1）.age-（*（struct stu*）p2）.age

//结构体变量.成员名 或者 结构体指针->成员名

}

//创建用名字比较的方法

int cmp_stu_by_name(const void* p1, const void* p2)

{

return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);//strcmp函数是专门用来比较字符串大小的

//字符串的比较方法：从左到右的顺序逐个比较两个字符串的字符，直到遇到第一个不同的字符，然乎根据字符的ascii值来确定两个字符串的大小关系。

}

//创建一个打印数组函数

void prinf(struct Stu s[], int num)

{

for (int i = 0; i < num; i++)

{

printf("第%d个同学的名字是%s,年龄是%d\n", i + 1, s[i].name, s[i].age);

}

}

int main()

{

struct Stu s[] = { {"zhangsan",20},{"lisi",30},{"wangwu",15} };

int num = sizeof(s) / sizeof(s[0]);//元素个数

int size = sizeof(struct Stu);//学生类型的大小

printf("比较前\n");

prinf(s, num);

printf("通过年龄比较后\n");

qsort(s, num, size, cmp_stu_by_age);

prinf(s, num);

printf("通过名字比较后\n");

qsort(s, num, size, cmp_stu_by_name);

prinf(s, num);

}

运行结果：

比较前

第1个同学的名字是zhangsan,年龄是20

第2个同学的名字是lisi,年龄是30

第3个同学的名字是wangwu,年龄是15

通过年龄比较后

第1个同学的名字是wangwu,年龄是15

第2个同学的名字是zhangsan,年龄是20

第3个同学的名字是lisi,年龄是30

通过名字比较后

第1个同学的名字是lisi,年龄是30

第2个同学的名字是wangwu,年龄是15

第3个同学的名字是zhangsan,年龄是20 

注意事项：

1.要访问结构体成员的两个方法：结构体变量.成员名    结构体指针->成员名

2.strcmp是专门用来比较字符串的大小的，并且它的返回值也恰好和qsort一样，所以可以直接去调用。字符串的比较方法：从左到右的顺序逐个比较两个字符串的字符，直到遇到第一个不同的字符，然乎根据字符的ascii值来确定两个字符串的大小关系。

3.结构体类型相较于整型类型，不能直接用+-<>等运算符，因为结构体中的成员属性可能有多个，直接比较编译器无法判断根据哪一个成员属性来比较。

三、qsort的模拟实现

       qsort展现的是不同数据类型的快速排序，在学习qsort之前，我只知道冒泡排序，而冒泡排序只能排序整型类型，那么我们可以通过会回调函数的方法，来改造冒泡排序，使其成为可以排序任意数据类型的排序方法。

     在模拟实现前，我们要比较qsort和冒泡排序，两者的数据类型不一样，所以我们对他的改造需要体现在两个方面。

1.由于数据类型不同，所以比较的方法必须改造。

2.由于不同数据类型占用字节大小不同，在利用指针偏移量操作的时候会有差异，所以交换的方法也必须改造。

3.由于数据类型不同，创建比较方法和交换方法时传入的两个参数必须是void*类型

3.模拟实现qsort，就要保证改造的排序函数bubble的返回类型和形参都要保持一致。

<code>int int_cmp(const void* p1, const void* p2)//比较方法

{

return(*(int*)p1 - *(int*)p2);

}

void swap(void* p1, void* p2, int size)//交换方法，这里要引入size，让swap函数知道交换的数据是什么类型

{

for (int i = 0; i < size; i++)

{

char temp = *((char*)p1+ i);//void*类型必须要先强制转化成char*类型

*((char*)p1 + i) = *((char*)p2 + i);

*((char*)p2 + i) = temp;

//为什么这里要使用字符类型？，因为我们并不知道传入的是什么数据类型，所以用char*（1个字节）来作为单位元，每次交换一个字节,交换次数恰好和size相同

}

}

void bubble(void* base, int num, int size, int (*cmp)(const void* p1, const void* p2))

{

for (int i = 0; i < num - 1;i++)

{

for (int j = 0; j < num - i - 1; j++)

{

if (int_cmp((char*)base + j * size, (char*)base + (j + 1) * size)>0)//不知道是什么数据类型，所以用char*比较好操作，一次只操作一个字节。

{

swap((char*)base + j * size, (char*)base + (j + 1) * size, size);

}//使用前必须强转成char*类型

}

}

}

int main()

{

int arr[] = { 9,8,7,6,5,4,0,2,1,3 };

int num = sizeof(arr) / sizeof(arr[0]);//确定数组的个数

int size = sizeof(int);//确定数组的每个元素占用字节大小

bubble(arr, num, size, int_cmp);

for (int i = 0; i < num; i++)

{

printf("%d ", arr[i]);

}

printf("\n");

return 0;

}

运行结果：0 1 2 3 4 5 6 7 8 9 

       要注意的是，由于交换方法和比较方法的改造，由于不知道比较的是什么数据类型，所以都强转成char*类型进行操作，因为char*类型操作一次是一个字节，方便计算。这样恰好就是一次交换一个字节，执行size次后就完成整个元素的交换。所以必须传入size。

四、NULL、\0、0、'0'、null、NUL的区别

NULL:本质是0，一般用于指针的初始化

\0：\ddd形式的转移字符，本质也是0，在字符串中作为结束标志，ASCII码值为0

0：数字0

'0'：字符0，ASCII码值为48

null/NUL:本质就是\0，作为字符串结束标志

五、C99中的变长数组

        在C99标准之前，C语⾔在创建数组的时候，数组大小的指定只能使⽤常量、常量表达式，或者如果我们初始化数据的话，可以省略数组⼤⼩。

int arr1[10];

int arr2[3+5];

int arr3[] = {1,2,3};

    这样的语法限制，让我们创建数组就不够灵活，有时候数组⼤了浪费空间，有时候数组⼜⼩了不够⽤的。 

     C99中给⼀个变⻓数组（variable-length array，简称 VLA）的新特性，允许我们可以使⽤变量指定数组大小。

int n = a+b;

int arr[n];

     上⾯⽰例中，数组 arr 就是变⻓数组，因为它的⻓度取决于变量 n 的值，编译器没法事先确定，只有运⾏时才能知道 n 是多少。

   变⻓数组的根本特征，就是数组⻓度只有运⾏时才能确定，所以变⻓数组不能初始化。它的好处是程序员不必在开发时，随意为数组指定⼀个估计的⻓度，程序可以在运⾏时为数组分配精确的⻓度。有 ⼀个⽐较迷惑的点，变⻓数组的意思是数组的⼤⼩是可以使⽤变量来指定的，在程序运⾏的时候，根据变量的⼤⼩来指定数组的元素个数，⽽不是说数组的⼤⼩是可变的。数组的大小⼀旦确定就不能再变化了。

     遗憾的是在VS2022上，虽然⽀持⼤部分C99的语法，没有⽀持C99中的变⻓数组，没法测试；