指针进阶（二）
指针进阶（二）
1.函数指针数组
之前已经讲解过了整型指针数组，用于存放整型指针。那么这里的函数指针数组就是用于存放函数指针的。写法是怎样的呢？
void test()
{
printf("hehe\n");
}
int main()
{
void(*pf[10])() = { test };
return 0;
}
代码的第7行，pf先与[]结合，说明pf是个数组名，将 pf[10]去掉，剩下的部分就是数组的元素类型，即void(*)();。所以pf是个函数指针数组。
1.1函数指针数组的应用实例
当我们想要实现一个对于整数的四则运算的计算器时，我们或许可以这样写：
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;
}
int main()
{
int x = 0;
int y = 0;
int input = 0;
int ret = 0;
do
{
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("请输入操作数:\n");
scanf("%d %d", &x, &y);
ret = Add(x, y);
printf("%d\n", ret);
break;
case 2:
printf("请输入操作数:\n");
scanf("%d %d", &x, &y);
ret = Sub(x, y);
printf("%d\n", ret);
break;
case 3:
printf("请输入操作数:\n");
scanf("%d %d", &x, &y);
ret = Mul(x, y);
printf("%d\n", ret);
break;
case 4:
printf("请输入操作数:\n");
scanf("%d %d", &x, &y);
ret = Div(x, y);
printf("%d\n", ret);
break;
case 0:
printf("退出程序!\n");
break;
default:
printf("您的输入有误，请重新输入！\n");
}
} while (input);
return 0;
}
但是这种写法会导致代码中重复的内容过多。那么能否改进改进呢？
我们观察这四个函数，可以发现他们的返回值和函数参数都是相同的。所以可以将这四个函数存放进一个函数指针数组中，这样在switch语句中调用对应的函数时，就可以使用下标进行快速访问。
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;
}
int main()
{
int x = 0;
int y = 0;
int input = 0;
int ret = 0;
int(*pf[5])(int, int) = { 0,Add,Sub,Mul,Div };
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf("*************************\n");
printf("请输入你想做的运算：");
scanf("%d", &input);
if (input >= 1 && input <= 4)
{
printf("请输入操作数：\n");
scanf("%d %d", &x, &y);
ret = pf[input](x, y);
printf("运算结果为：%d\n", ret);
}
else if(input==0)
{
printf("退出程序！\n");
}
else
{
printf("你的输入有误，请重新输入！\n");
}
} while (input);
return 0;
}
代码的第23行，这里使用0进行占位，将1，2，3，4这四个下标所对应的位置各自对应相应的函数。
1.2指向函数指针数组的指针
指向函数指针数组的指针是一个指针，其指向一个函数指针的数组。
void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针pfun
void (*pfun)(const char*) = test;
//函数指针的数组pfunArr
void (*pfunArr[5])(const char* str);
pfunArr[0] = test;
//指向函数指针数组pfunArr的指针ppfunArr
void (*(*ppfunArr)[5])(const char*) = &pfunArr;
return 0;
}
这里注意：函数名代表的是函数的地址，&函数名代表的也是函数的地址。
2.回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
我们可以通过回调函数的机制，可以将上面的计算器的代码再进行改进。
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 Calc(int(*pf)(int, int))
{
int x = 0;
int y = 0;
printf("请输入两个操作数：\n");
scanf("%d %d", &x, &y);
int ret = pf(x, y);
printf("%d\n", ret);
}
int main()
{
int x = 0;
int y = 0;
int input = 0;
int ret = 0;
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \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");
}
} while (input);
return 0;
}
2.1 qsort函数
查看官方文档：
qsort函数可以对任意数组进行排序，包括结构体数组也可以。qsort函数有四个参数，第一个参数是目标数组的起始位置。第二个参数是数组中元素的个数。第三个参数是数组中每个元素的大小。第四个参数是一个函数，这个函数能够用于比较数组中的两个元素。
注意：这里qsort函数中的最后一个参数是一个函数名，这个函数的两个类型必须是void*类型的。为什么必须是void*类型的呢？
这是因为void*类型指针变量可以接收任意类型的指针变量。因为对于这个函数的设计者而言，他也不知道用户要比较的什么类型的元素，所以就设计了void*这个可以接收任意类型指针的“万能指针变量”，但是void*类型的指针变量不能进行解引用操作，也不能进行加减操作。例如：
//这段代码不会有任何的警告和报错。
int main()
{
int a = 0;
char c = 0;
float f= 1.0;
void* pv;
pv = &a;
pv = &c;
pv = &f;
return 0;
}
qsort函数的底层是快速排序算法，假定我们使用qsort函数对整数组中的元素进行排序：（qsort函数默认是升序排列的）
int compare_int(void* e1, void* e2)
{
return (*(int*)e1 - *(int*)e2);
}
void print(int* p,int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", p[i]);
}
}
int main()
{
int arr[10] = { 1,2,4,1,6,2,21,4745,64 };
int sz = sizeof(arr) / sizeof(arr[0]);
print(arr, sz);
printf("\n");
qsort(arr,sz,sizeof(arr[0]),compare_int);
print(arr, sz);
return 0;
}
这里使用冒泡排序模拟实现qsort函数，对乱序的整型数组进行排序。
void swap(char* e1,char*e2,int sz)
{
char tmp = 0;
while (sz--)
{
tmp = *e1;
*e1 = *e2;
*e2 = tmp;
e1++;
e2++;
}
}
int compare_int(const void* e1, const void* e2)
{
return (*(int*)e1 - *(int*)e2);
}
void myBubble(void* base, int num, int sz, int (*pf)(void*, void*))
{
int i = 0;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
if (pf((char*)base +j*sz, (char*)base + sz*(j + 1)) > 0)
{
swap((char*)base + j * sz,(char*)base+(j+1)*sz,sz);
}
}
}
}
void print(int* p, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", p[i]);
}
printf("\n");
}
int main()
{
int arr[10] = { 1,0,4,23,55,34,756,754,7,999 };
int sz = sizeof(arr) / sizeof(arr[0]);
print(arr, sz);
myBubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), compare_int);
print(arr, sz);
return 0;
}
这里bubble函数和库函数qsort的参数类型设计的是一样的，这里要特别注意，qsort函数的最后一个参数是一个函数名，这个函数的参数的是void*类型的，也就是说这个函数是用于接收要比较的两个元素的地址的，并不是接收两个函数本身，所以要如何找到这两个要比较的元素的地址呢？可以将base这个参数强制转换为char*类型的，这样子base每执行一次+1操作都会向后移动一个字节，要比较的元素的大小是已知的，为sz。假如要找到bubble函数中找到arr[4]这个元素的地址，就可
(char*)base+4*sizeof(int);，base指针向后移动16个字节，就成功找到了arr[4]的地址。
在swap函数中，参数是两个元素的地址，第三个参数是每个元素的大小，要交换这两个元素，只需要交换这两个元素的每一个字节就可以了。
假如要比较结构体数组：(假设以姓名为标准进行比较：)
struct Student
{
char name[20];
int age;
};
void swap(char* e1, char* e2, int sz)
{
char tmp = 0;
while (sz--)
{
tmp = *e1;
*e1 = *e2;
*e2 = tmp;
e1++;
e2++;
}
}
int compare_name(const void* e1, const void* e2)
{
return strcmp(((struct Student*)e1)->name, ((struct Student*)e2)->name);
}
void myBubble(void* base, int num, int sz, int (*pf)(const void*,const void*))
{
int i = 0;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
if (pf((char*)base + j * sz, (char*)base + sz * (j + 1)) > 0)
{
swap((char*)base + j * sz, (char*)base + (j + 1) * sz, sz);
}
}
}
}
int main()
{
struct Student arr[3] = { {"zhangshan",12},{"lisi",20},{"wangwu",16} };
int sz = sizeof(arr) / sizeof(arr[0]);
myBubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), compare_name);
return 0;
}
注意：这里字符串的比较是使用的strcmp函数进行比较的。不能直接进行字符串之间的加减操作。
假定以年龄为标准进行比较：
struct Student
{
char name[20];
int age;
};
void swap(char* e1, char* e2, int sz)
{
char tmp = 0;
while (sz--)
{
tmp = *e1;
*e1 = *e2;
*e2 = tmp;
e1++;
e2++;
}
}
int compare_int(const void* e1, const void* e2)
{
return ((struct Student*)e1)->age - ((struct Student*)e2)->age;
}
void myBubble(void* base, int num, int sz, int (*pf)(const void*,const void*))
{
int i = 0;
for (i = 0; i < num - 1; i++)
{
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
if (pf((char*)base + j * sz, (char*)base + sz * (j + 1)) > 0)
{
swap((char*)base + j * sz, (char*)base + (j + 1) * sz, sz);
}
}
}
}
int main()
{
struct Student arr[3] = { {"zhangshan",12},{"lisi",20},{"wangwu",16} };
int sz = sizeof(arr) / sizeof(arr[0]);
myBubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), compare_int);
return 0;
}
这里就可以直接对年龄进行相减的操作了。
3.指针和数组的习题组
请预测下面代码的运行结果：
前言：数组名只在两种情况下代表数组名整个数组：其他情况下，数组名代表的是数组首元素的地址。
- sizeof（数组名），当数组名单独放在sizeof内部，此时数组名代表的是整个数组。并且计算出的也是整个数组的大小。
- &数组名，当数组名被单独放在&符号之前时，此时的数组名代表的是整个数组的地址，数组名代表的是整个数组。
//一维数组
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a));//16
//数组名被单独放在sizeof内部，代表的是整个数组，计算结果是整个数组的大小。
printf("%d\n",sizeof(a+0));//4/8
//数组名不符合前言中的任何一种情况，此时数组名代表数组首元素的地址，地址的大小为4/8个字节
printf("%d\n",sizeof(*a));//4
//数组名不符合前言中的任何一种情况，此时数组名代表数组首元素的地址，解引用操作，拿到了int类型的首元素，大小4字节。
printf("%d\n",sizeof(a+1));//4/8
//数组名不符合前言中的任何一种情况，此时数组名代表数组首元素的地址，+1是第二个元素的地址。为4/8个字节。
printf("%d\n",sizeof(a[1]));//4
//a[1]是数组的第二个元素，大小是4字节。
printf("%d\n",sizeof(&a));//4/8
//&a取出的是整个数组的地址，但也是地址，大小为4/8个字节
printf("%d\n",sizeof(*&a));//16
//对数组名进行&和*操作，得到的最终还是数组名，相当于是将数组名单独放在sizeof内部，计算的是整个数组的大小。
printf("%d\n",sizeof(&a+1));//4/8
//&a取出整个数组的地址，+1操作跳过整个数组，得到一个新地址，但只要是地址，就是4/8个字节。
printf("%d\n",sizeof(&a[0]));//4/8
//a[0]是数组首元素，&a[0]是数组首元素的地址，地址的大小是4/8个字节。
printf("%d\n",sizeof(&a[0]+1));//4/8
//&a[0]是数组首元素的地址，+1操作，得到了数组中第二个元素的地址，大小为4/8个字节。
//字符数组
char arr[] = {'a','b','c','d','e','f'};
printf("%d\n", sizeof(arr));//6
//sizeof(数组名)计算的是整个数组的大小。数组中有6个元素，大小就是6.
printf("%d\n", sizeof(arr+0));//4/8
//数组名没有单独放在sizeof内部，所以代表的是首元素的地址，+0操作，还是首元素的地址，地址就是4/8字节
printf("%d\n", sizeof(*arr));//1
//*arr是数组首元素，数组中的元素都是char类型，所以计算结果为1字节
printf("%d\n", sizeof(arr[1]));//1
//arr[1]是数组中的第二个元素，大小是1个字节。
printf("%d\n", sizeof(&arr));//4/8
//&arr取出的是整个数组的地址，地址的大小是4/8.
printf("%d\n", sizeof(&arr+1));//4/8
//&arr代表的是整个数组的地址，+1操作跳过整个数组，得到一个新的地址，还是4/8个字节。
printf("%d\n", sizeof(&arr[0]+1));//4/8
//&arr[0]是数组首元素的地址，+1操作，得到数组第二个元素的地址，为4/8字节。
//要注意strlen函数的机制，strlen函数会计算从当前地址开始，一直到'\0'之前的所有元素个数
printf("%d\n", strlen(arr));//随机值
//arr是数组的起始地址，但是arr数组中并没有'\0'，所以strlen会一直向后计算，知道遇到了'\0'为止。所以是个随机值。
printf("%d\n", strlen(arr+0));//随机值
//也是随机值，和上面的原因一样的
printf("%d\n", strlen(*arr));//报错
//这里将数组的第一个元素的ascll码，即97传过去了，意味着strlen函数要从97地址处开始向后计算，但是该内存空间是不允许被访问的，所以会报错。
printf("%d\n", strlen(arr[1]));//报错
//这里的原因与上一个类似的
printf("%d\n", strlen(&arr));//随机值
//&arr取出整个数组的地址，传递给strlen，由于不知道'\0'的位置，所以会计算出一个随机值。
printf("%d\n", strlen(&arr+1));//随机值
//&arr+1得到的是跳过一个数组之后的地址，由于不知道'\0'的位置，所以计算结果是随机值。
printf("%d\n", strlen(&arr[0]+1));//随机值
//同样的道理，也会计算出一个随机值
char arr[] = "abcdef";//要注意：字符串的末尾会自动添加'\0'。所以这个数组中含有7个元素
printf("%d\n", sizeof(arr));//7
//sizeof(数组名)计算的是整个数组的大小，要注意：字符串的末尾会自动添加'\0'，会被sizeof加入计算结果的。
printf("%d\n", sizeof(arr+0));//4
//arr没有单独放在sizeof内部，+0仍然代表的是首元素的地址，大小4/8字节
printf("%d\n", sizeof(*arr));//1
//*arr是数组的首元素，数组是char类型数组，元素的大小都为1字节
printf("%d\n", sizeof(arr[1]));//1
//arr[1]是数组的第二个元素，数组是char类型的数组，大小都是1字节
printf("%d\n", sizeof(&arr));//4/8
//&arr取出的是整个数组的地址，只要是地址，大小就是4/8字节
printf("%d\n", sizeof(&arr+1));//4/8
//&arr取出整个数组的地址，+1操作跳过一个数组得到一个新的地址，大小仍然为4/8
printf("%d\n", sizeof(&arr[0]+1));//4/8
//&arr[0]取出数组首元素的地址，+1操作得到数组第二个元素的地址，只要是地址，大小就是4/8字节
printf("%d\n", strlen(arr));//6
//数组中含有'\0',arr是数组首元素的地址，到'\0'这个字符之前共有6个元素
printf("%d\n", strlen(arr+0));//6
//相同的道理
printf("%d\n", strlen(*arr));//报错
//*arr是将a字符的ascll码值传递给了strlen函数，这块内存空间访问是非法的，报错。
printf("%d\n", strlen(arr[1]));//报错
//arr[1]是将b字符的ascll码值传入了，该空间访问也是非法的，报错
printf("%d\n", strlen(&arr));//6
//&arr是数组的首地址，传入strlen函数时，会被转化为char*类型。得出计算结果为6
printf("%d\n", strlen(&arr+1));//随机值
printf("%d\n", strlen(&arr[0]+1));//5
//&arr[0]+1是第二个元素的地址，向后计算时不会将第一个元素算入，结果为5
char *p = "abcdef";
printf("%d\n", sizeof(p));//4/8
//p是一个指针变量，指向字符串的第一个元素的地址，指针变量的大小是4/8字节
printf("%d\n", sizeof(p+1));//4/8
//p+1是第二个字符的地址，地址的大小是4/8个字节
printf("%d\n", sizeof(*p));//1
//*p是字符串的第一个元素，大小是1字节
printf("%d\n", sizeof(p[0]));//1
//p[0]是字符串的第一个元素，大小也是1字节
printf("%d\n", sizeof(&p));//4/8
//&p是指针变量的地址，&p是个二级指针，大小也是4/8字节
printf("%d\n", sizeof(&p+1));//4/8
//&p+1也是一个二级指针，大小是4/8字节
printf("%d\n", sizeof(&p[0]+1));//4/8
//&p[0]+1是数组第二个元素的地址，大小是4/8字节
printf("%d\n", strlen(p));//6
//p指向的是字符串的第一个元素的地址，strlen能计算出这个字符串中的元素个数，为6
printf("%d\n", strlen(p+1));//5
//p+1地址处开始算，元素个数就是5个
printf("%d\n", strlen(*p));//报错
//*p的值是97，该空间访问是非法的，会报错
printf("%d\n", strlen(p[0]));//报错
//p[0]的值是97，同理，该空间访问非法，会报错
printf("%d\n", strlen(&p));//随机值
//&p是p这个指针变量的地址，由于不知道'\0'的位置，所以计算出一个随机值
printf("%d\n", strlen(&p+1));//随机值
//&p是二级指针，+1操作之后，仍因为不知'\0'的位置，最终计算出一个随机值。
printf("%d\n", strlen(&p[0]+1));//5
//&p[0]+1是数组第二个元素的地址，第一个元素不会被算入，计算结果就是5了
//二维数组
int a[3][4] = {0};
printf("%d\n",sizeof(a));//48
//sizeof（数组名）计算的是整个数组的大小，为48字节
printf("%d\n",sizeof(a[0][0]));//4
//a[0][0]是数组中第一行第一列的元素0，大小是4字节
printf("%d\n",sizeof(a[0]));//16
//a[0]是二维数组中第一个一维数组的数组名，计算的是整个第一行的大小，为16个字节
printf("%d\n",sizeof(a[0]+1));//4/8
//a[0]并没有单独放在sizeof内部，所以代表的是二维数组第一个一维数组的第一个元素的地址，也就是int*类型的，再+1操作，代表的是二维数组的第一个一维数组的第二个元素地址，大小是4/8字节
printf("%d\n",sizeof(*(a[0]+1)));//4
//sizeof括号里的内容可以改写为：a[0][1]，所以计算结果为4
printf("%d\n",sizeof(a+1));//4/8
//a这个数组名没有单独放在sizeof内部，所以a代表第一个一维数组的地址，+1代表第二个一维数组的地址，地址的大小是4/8字节
printf("%d\n",sizeof(*(a+1)));//16
//sizeof括号里的可改写做：a[1]，a[1]是数组第二行元素数组名，被单独放在sizeof内部，计算的是第二行元素的大小。16
printf("%d\n",sizeof(&a[0]+1));//4/8
//&a[0]代表的是第一个一维数组的地址，+1代表的第二个一维数组的地址，地址的大小是4/8字节
printf("%d\n",sizeof(*(&a[0]+1)));//16
//sizeof括号里可以改写：a[1]，是第二个一维数组的数组名，被单独放在sizeof的括号里，计算的是第二个一维数组的大小。16
printf("%d\n",sizeof(*a));//16
//*a与a[0]等价，被单独放在sizeof内部，计算的是第一行元素的大小。16
printf("%d\n",sizeof(a[3]));//16
虽然a[3]不存在，但是与sizeof的计算结果无关，sizeof只关心括号里的数据类型。最终将这个数据类型的大小算出来即可。
//a[3]也是一个一维数组的数组名，被单独放在sizeof内部，计算的是一行的元素的大小，为16.
结尾：指针进阶的内容先讲解到这里，后续会继续更新，如有不足，敬请指正！！