©作者:末央＆

©系列:C语言初阶(适合小白入门)
©说明:以凡人之笔墨，书写未来之大梦

回调函数

概念

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

例如:

#include<stdio.h>
void test1()
{
	printf("hello\n");
}
void test2(void(*p)())
{
	p(); //指针p被用来调用其所指向的函数
}
int main()
{
	test2(test1);//将test1函数的地址传递给test2
	return 0;
}

在该代码中test1函数不是由该函数的实现方直接调用，而是将其地址传递给test2函数，在test2函数中通过函数指针间接调用了test1函数，那么函数test1就被称为回调函数。

回调函数的使用 - qsort函数

其实回调函数并不是很难见到，在用于快速排序的库函数qsort中便运用了回调函数。

void qsort(void*base,size_t num,size_t width,int(*compare)(const void*e1,const void*e2));

qsort函数的第一个参数是待排序的内容的起始位置；第二个参数是从起始位置开始，待排序的元素个数；第三个参数是待排序的每个元素的大小，单位是字节；第四个参数是一个函数指针。qsort函数的返回类型为void。
qsort函数的第四个参数是一个函数指针，该函数指针指向的函数的两个参数的参数类型均为const void*，返回类型为int。当参数e1小于参数e2时返回小于0的数；当参数e1大于参数e2时返回大于0的数；当参数e1等于参数e2时返回0。

列如，我们要排一个整型数组：

#include<stdio.h>
int compare(const void* e1, const void* e2)
{
	return *((int*)e1) - *((int*)e2);
}//自定义的比较函数
int main()
{
	int arr[] = { 2, 5, 1, 8, 6, 10, 9, 3, 5, 4 };
	int sz = sizeof(arr) / sizeof(arr[0]);//元素个数
	qsort(arr, sz, 4, compare);//用qsort函数将arr数组排序
	return 0;
}

注意：qsort函数默认将待排序的内容排为升序，如果我们要排为降序可将自定义的比较函数的两个形参的位置互换一下即可。（本来是a>b交换(升序),结果b>a交换(降序)）

在qsort函数中我们传入了一个函数指针，最终qsort函数会在其内部通过该函数指针调用该函数，那么我们的这个自定义比较函数就被称为回调函数。

sizeof/strlen深度理解

概念

手脑并用

1.sizeof-数组/指针专题

//x86环境
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a+0));	//1
printf("%d\n", sizeof(*&a));//2
char arr[] = "abcdef";
printf("%d\n", sizeof(*arr));//3
int a[3][4] = { 0 };
printf("%d\n", sizeof(a[0] + 1));//4
printf("%d\n", sizeof(a + 1));//5
printf("%d\n", sizeof(*(a + 1)));//6
printf("%d\n", sizeof(a[3]));//7

1.这里不同于我们常见的sizeof(a)我们在不是单独一个数组名a在sizeof里面，所以我们计算的不是整个数组的大小。这里a数组名是首元素地址，指针就是地址地址就是指针，地址+0不变，指针大小在x86环境下4,x64环境下为8。所以答案是4

2.这里有两种角度来解释
角度一：
*和&抵消了(上一章提到过),就是sizeof(a)计算整个数组的大小为16
角度二:
&a是数组的地址，数组的地址是不是要用一个数组指针来存放。int( * )[4]是数组指针变量类型， 而 * 的访问字节数取决于变量类型,那么就是访问16个字节的数组指针。

3.*arr，arr是首元素地址，*找到字符’a’,sizeof()计算’a’占用空间，结果为1字节

4.和第1题有一点相似，这里要注意a[0]是一维数组的数组名(二维数组的每个元素是一个一维数组)，而数组名没有单独放在sizeof内部而是+1,地址+1还是一个地址a[1],则为4(x86环境)

5.这里很容易加1加为整个二维数组，其实不是，还是同上一题，a为二维数组名但是不是单独放在sizeof内部，则数组名是首元素地址而不是计算整个二维数组大小，数组首元素是第一个一维数组,+1就是指向第二个一维数组的地址，地址结果就为4

6.这里还记得我们上一节讲的指针和数组互化公式吗*(数组名+变量/常量)=数组名[变量/常量]这里*(a+1)=a[1],就是第二个一位数组名，为16

7.或许有很多人看了一眼就直接说是越界访问，理论上有道理，但是我们都忽略了sizeof他实际上不会真正去计算表达式的,他是不会访问a[3]这块空间的，他是靠表达式结果的类型来出结果的,a[3]的类型就是int 4就为16

总结：如果遇到很难分析的题目，就记住一点sizeof里面的表达式并不会真正计算，他的结果是取决于表达式结果的类型包括sizeo(a[0]+1)他的表达式结果是一个地址,地址的类型是指针，指针就是4/8个字节。其他以此类推

2.strlen-数组/指针专题

//x86环境
char arr[] = { 'a','b','c','d','e','f' };
printf("%d\n", strlen(*arr));	//1
char* p = "abcdef";
printf("%d\n", strlen(&p));	//2

1.这个代码有问题，arr是首元素地址，*arr找到首元素arr[0],就是’a’，然后strlen函数参数是需要一个地址,他会把’a’==97当作一个地址来访问，可是我们并没有97这个地址的访问权限，这里就会形成非法访问
2.这里我们直接上图

这里我们可以直接看到他们&p和p的地址明显不一样，p是指针变量，存储的是"abcdef"这个常量字符串的地址。而&p是一个地址是指针变量的地址.所以在这个地址不知道什么时候遇到\0，故而结果为随机值

指针面试题专题

//在X86环境下
//假设结构体的⼤⼩是20个字节
//程序输出的结构是啥？
struct Test
{
```int Num;
 char *pcName;
 short sDate;
 char cha[2];
 short sBa[4];
}*p = (struct Test*)0x100000;
int main()
{
 printf("%p\n", p + 0x1);
 printf("%p\n", (unsigned long)p + 0x1);
 printf("%p\n", (unsigned int*)p + 0x1);
 return 0;
}

第一个就是结构体指针+1,既然是指针他的±运算就取决于他的指针类型,int*一次跳过4个字节，题目中告知结构体大小是20字节。所以我们+1就跳过20个字节,则16进制表示100014

第二个很容易出错，把他强制转换为unsigned long形，这是无符号整数+1就是100001

第三个则是无符号整形指针+1，类型一次跳过4个字节，则为100004

//假设环境是x86环境，程序输出的结果是啥？
#include <stdio.h>
int main()
{
 int a[5][5];
 int(*p)[4];
 p = a;
 printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
 return 0;
}

这里我们之间用一张图来阐述：

p是一个int(*)[4]的数组指针，但是a的类型是int( * )[5],所以我们第一个值和第二个值按理来说都是负数，但是第一个值是以地址的形式来输出，"地址在内存中不分原反补码，但是-4在内存中是以补码的形式存储，所以直接打印FF FF FF FC

第二个打印原码-4

#include <stdio.h>
int main()
{
 char *a[] = {"work","at","alibaba"};
 char**pa = a;
 pa++;
 printf("%s\n", *pa);
 return 0;
}

指针数组a每一个元素是一个char指针，pa存储第一个元素char地址,+1就是指向下一个元素(另外一个char*),打印他的字符串at
4.

#include <stdio.h>
int main()
{
 char *c[] = {"ENTER","NEW","POINT","FIRST"};
 char**cp[] = {c+3,c+2,c+1,c};
 char***cpp = cp;
 printf("%s\n", **++cpp);
 printf("%s\n", *--*++cpp+3);
 printf("%s\n", *cpp[-2]+3);
 printf("%s\n", cpp[-1][-1]+1);
 return 0;
}

结果就是: