6.函数指针数组
数组是一个存放相同类型数据的存储空间，指针数组是存放指针变量的数组。
int *arr[10];
//数组的每个元素是int*
那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？
int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];
答案是：parr1
分析：
parr1 先和 [ ] 结合，说明 parr1是数组，数组的内容是什么呢？
是 int (*)( ) 类型的函数指针。
例如如下代码进一步i姐函数指针数组：
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int main()
{
int (*pf1)(int, int) = &Add;
int (*pf2)(int, int) = ⋐
//数组中存放类型相同的多个元素
int (*pfArr[4])(int, int) = { &Add, &Sub };//pfArr 是函数指针数组 - 存放函数指针的数组
return 0;
}
函数指针数组的用途： 转移表
例如：计算器
void menu()
{
printf("****************************\n");
printf("*** 1. add 2. sub ***\n");
printf("*** 3. mul 4. div ***\n");
printf("*** 0. exit ***\n");
printf("****************************\n");
}
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 input = 0;
int x = 0;
int y = 0;
int ret = 0;
do
{
menu();
printf("请输入选择>:");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入两个操作数》");
scanf("%d%d", &x, &y);
ret = Add(x, y);
printf("%d\n", ret);
break;
case 2:
printf("请输入两个操作数》");
scanf("%d%d", &x, &y);
ret = Sub(x, y);
printf("%d\n", ret);
break;
case 3:
printf("请输入两个操作数》");
scanf("%d%d", &x, &y);
ret = Mul(x, y);
printf("%d\n", ret);
break;
case 4:
printf("请输入两个操作数》");
scanf("%d%d", &x, &y);
ret = Div(x, y);
printf("%d\n", ret);
break;
case 0:
printf("退出游戏");
default:
printf("输入错误");
}
} while (input);
return 0;
}
用函数指针实现：
void menu()
{
printf("****************************\n");
printf("*** 1. add 2. sub ***\n");
printf("*** 3. mul 4. div ***\n");
printf("*** 0. exit ***\n");
printf("****************************\n");
}
//+ - * / && || & | >> <<
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 input = 0;
int x = 0;
int y = 0;
int ret = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
//函数指针数组 - 转移表
int (*pfArr[])(int, int) = {NULL, Add, Sub, Mul, Div};
// 0 1 2 3 4
if (0 == input)
{
printf("退出计算器\n");
}
else if (input >= 1 && input <= 4)
{
printf("请输入2个操作数:");
scanf("%d %d", &x, &y);
ret = pfArr[input](x, y);
printf("ret = %d\n", ret);
}
else
{
printf("选择错误，重新选择!\n");
}
} while (input);
return 0;
}
7.指向函数指针数组的指针
指向函数指针数组的指针是一个 指针；
指针指向一个 数组 ，数组的元素都是 函数指针；
8.回调函数
回调函数是一个通过 函数指针 调用的 函数。 如果你把函数的指针（地址）作为一个参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
void menu()
{
printf("****************************\n");
printf("*** 1. add 2. sub ***\n");
printf("*** 3. mul 4. div ***\n");
printf("*** 0. exit ***\n");
printf("****************************\n");
}
//+ - * / && || & | >> <<
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;
int ret = 0;
printf("请输入2个操作数:");
scanf("%d %d", &x, &y);
ret = pf(x, y);
printf("ret = %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);
return 0;
}
例1：使用回调函数，模拟实现qsort（采用冒泡的方式）
一般冒泡排序：
void print_arr(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
void bubble_sort(int arr[], int sz)
{ //趟数
int i = 0;
for (i = 0; i < sz - 1; i++)
{ //每一趟冒泡排序的过程
int j = 0;
for (j = 0; j < sz - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
}
}
int main()//数据
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
print_arr(arr, sz);
bubble_sort(arr, sz);//冒泡排序
print_arr(arr, sz);
return 0;
}
运行结果：
这种冒泡排序存在的缺陷：
qsort（采用冒泡的方式）
有关qsort（）函数
1.首元素地址base
我们要排序一组数据，首先我们需要找到这组数据在哪里，因此我们直接将首元素的地址传给qsort函数，来确定从哪里开始排序。
2.元素个数num
我们知道了从哪里开始我们知道了从哪开始，也要知道在哪结束才能确定一组需要排序的数据，但是我们不方便直接将结尾元素的地址传入函数，因此我们将需要排序的元素的个数传给qsort函数来确定一组数据。
3.元素大小size
我们知道qsort函数能排序任意数据类型的一组数据，因此我们用void类型的指针来接收元素，但是我们知道void类型的指针不能进行加减操作，也就无法移动，那么在函数内部我们究竟用什么类型的指针来操作变量呢？我们可以将void类型的指针强制类型转换成char类型的指针后来操作元素，因为char*类型的指针移动的单位字节长度是1个字节，我们只需要再知道我们需要操作的数据是几个字节就可以操作指针从一个元素移动到下一个元素，因此我们需要将元素大小传入qsort函数。
4.自定义比较函数compar
我们需要告诉qsort函数我们希望数据按照怎么的方式进行比较，比如对于几个字符串，我们可以比较字符串的大小（strcmp），也可以比较字符串的长度（strlen），因此我们要告诉qsort函数我们希望的比较方式，我们就需要传入一个比较函数compar就简写为cmp吧。
//代码案例：
#include <stdlib.h>
#include <string.h>
void print_arr(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
int cmp_int(const void* e1, const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
//测试qsort排序整型数据
void test1()
{
int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
print_arr(arr, sz);
qsort(arr, sz, sizeof(arr[0]), cmp_int);
print_arr(arr, sz);
}
int main()
{
test1();
return 0;
}
运行结果：
补充：
1.void* 类型的指针 - 不能进行解引用操作符，也不能进行±整数的操作
2.void* 类型的指针是用来存放任意类型数据的地址
3.void* 无具体类型的指针
int main()
{
char c = 'w';
char* pc = &c;
int a = 100;
//int* p = &c;//不可以存放char*类型
void* pv = &c;//存放char*
pv = &a;//存放int*
return 0;
}
例如：
测试qsort排序结构体数据
1.按照年龄比较
#include<stdio.h>
#include<stdio.h>
struct Stu
{
char name[20];
int age;
};
int cmp_stu_by_age(const void* e1, const void* e2)
{
return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void test1()
{
struct Stu arr[] = { {"zhanhsan", 20}, {"lisi", 30}, {"wangwu", 12} };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
}
int main()
{
test1();
return 0;
}
2.按照名字比较：
struct Stu
{
char name[20];
int age;
};
int cmp_stu_by_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void test2()
{
struct Stu arr[] = { {"zhanhsan", 20}, {"lisi", 30}, {"wangwu", 12} };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
test1();
return 0;
}
qsort内部实现
#include <string.h>
void print_arr(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
void swap(char* buf1, char* buf2, size_t size)
{
int i = 0;
for (i = 0; i < size; i++)
{
char tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
//泛型编程
void bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void* e1, const void*e2))
{
//冒泡排序的趟数
int i = 0;
for (i = 0; i < num - 1; i++)
{
//一趟冒泡排序
int j = 0;
for (j = 0; j < num - 1 - i; j++)
{
//if (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 cmp_int(const void* e1, const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
void test1()
{
int arr[] = { 0,1,2,3,4,5,6,7,8,9 };//升序
//排序为降序
int sz = sizeof(arr) / sizeof(arr[0]);
print_arr(arr, sz);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
print_arr(arr, sz);
}
int main()
{
//整型数据/字符数据/结构体数据...
//可以使用qsort函数对数据进行排序
//测试bubble_sort，排序整型数据
test1();
return 0;
}//运行结果与上面相同
9.指针与数组笔试题
数组名的理解
数组名是数组元素的首元素的地址
但是有两个例外：
1.sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小，单位是字节
2.&数组名，这里的数组名表示整个数组，&数组名取出的是数组的地址
例1
#include<stdio.h>
int main()
{
//一维数组
int a[] = { 1,2,3,4 };//4个元素，每个元素使int类型(4个字节)
printf("%d\n", sizeof(a));//16,数组名a单独放在sizeof内部，数组名表示整个数组，计算的是整个数组的大小单位是字节，是16字节
printf("%d\n", sizeof(a + 0));//a并非单独放在sizeof内部，也没有&，所以数组名a是数组首元素的地址，a+0还是首元素的地址
//是地址大小就是4/8 Byte
printf("%d\n", sizeof(*a));//a并非单独放在sizeof内部，也没有&,所以数组名a是数组首元素的地址
//*a 就是 首元素，大小就是4Byte //*a == *(a+0) == a[0]
printf("%d\n", sizeof(a + 1));//a并非单独放在sizeof内部，也没有&，所以数组名a是数组首元素的地址,a+1就是第二个元素的地址
//a+1 == &a[1] 是第2个元素的地址，是地址就是4/8个字节
printf("%d\n", sizeof(a[1]));//a[1]就是数组的第二个元素，这里计算的就是第二个元素的大小，单位是字节 - 4
printf("%d\n", sizeof(&a));//&a - 是取出数组的地址，但是数组的地址也是地址，是地址就是4/8个Byte
//数组的地址 和 数组首元素的地址 的本质区别是类型的区别，并非大小的区别
//a -- int* int * p = a;
//&a -- int (*)[4] int (*p)[4] = &a;
printf("%d\n", sizeof(*&a));//16 对数组指针解引用访问一个数组的大小，单位是字节
//sizeof(*&a) --- sizeof(a) //16
printf("%d\n", sizeof(&a + 1));//&a数组的地址，&a+1还是地址，是地址就是4/8个字节
printf("%d\n", sizeof(&a[0]));//&a[0]是首元素的地址， 计算的是地址的大小 4/8 个字节
printf("%d\n", sizeof(&a[0] + 1));//&a[0]是首元素的地址，&a[0]+1就是第二个元素的地址，大小4/8个字节
//&a[1]
//&a[0]+1
//a+1
return 0;
}
运行结果：
例2：
//strlen 求字符串长度
//统计的是在字符串中\0之前出现的字符的个数
//
int main()
{
//字符数组
char arr[] = { 'a','b','c','d','e','f' };//6
printf("%d\n", strlen(arr));//随机值，arr是首元素的地址
printf("%d\n", strlen(arr + 0));//随机值，arr是首元素的地址, arr+0还是首元素的地址
//printf("%d\n", strlen(*arr));//err，arr是首元素的地址, *arr就是首元素 - 'a' - 97
//站在strlen的角度，认为传参进去的'a'-97就是地址，97作为地址，直接进行访问，就是非法访问
//printf("%d\n", strlen(arr[1]));//err, 'b' - 98
printf("%d\n", strlen(&arr));//随机值
//&arr -- char (*)[6]
//const char*
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//随机值
return 0;
}
运行结果
例3：
#include<stdio.h>
#include <string.h>
int main()
{
//字符数组
char arr[] = { 'a','b','c','d','e','f' };//6
printf("%d\n", sizeof(arr));//6 数组名arr单独放在sizeof内部，计算的是整个数组的大小，单位是字节
printf("%d\n", sizeof(arr + 0));//arr是首元素的地址==&arr[0]，是地址就是4/8个字节
//char*
//指针变量的大小和类型无关，不管什么类型的指针变量，大小都是4/8个字节
//指针变量是用来存放地址的，地址存放需要多大空间，指针变量的大小就是几个字节
//32位环境下，地址是32个二进制位，需要4个字节，所以指针变量的大小就是4个字节
//64位环境下，地址是64个二进制位，需要8个字节，所以指针变量的大小就是8个字节
//门缝里看指针，把指针给看扁了
//
printf("%d\n", sizeof(*arr));//arr是首元素的地址，*arr就是首元素，大小就是1Byte
printf("%d\n", sizeof(arr[1]));//1
printf("%d\n", sizeof(&arr));//&arr是数组的地址，sizeof(&arr)就是4/8个字节
printf("%d\n", sizeof(&arr + 1));//&arr+1 是跳过数组后的地址，是地址就是4/8个字节
printf("%d\n", sizeof(&arr[0] + 1));//第二个元素的地址，是地址就是4/8Byte
return 0;
}
运行结果：
例4：
int main()
{
char* p = "abcdef";
printf("%d\n", sizeof(p));//4/8 计算的是指针变量的大小
printf("%d\n", sizeof(p + 1));//p+1还是地址，大小是4/8个字节
printf("%d\n", sizeof(*p));//1个字节, *p == 'a'
printf("%d\n", sizeof(p[0]));//1个字节, p[0]--> *(p+0) --> *p == 'a';
printf("%d\n", sizeof(&p));//4/8个字节，&p 是地址
printf("%d\n", sizeof(&p + 1));//&p是地址，&p+1还是地址，是地址就是4/8个字节
printf("%d\n", sizeof(&p[0] + 1));//4/8
return 0;
}
运行结果：
例5：
#include<stdio.h>
int main()
{
char arr[] = "abcdef";
printf("%d\n", strlen(arr));//6 arr是首元素的地址
printf("%d\n", strlen(arr + 0));//6 arr是首元素的地址, arr+0还是首元素的地址
//printf("%d\n", strlen(*arr));//err arr是首元素的地址, *arr就是首元素 - 'a' - 97
//printf("%d\n", strlen(arr[1]));//err 'b' - 98
printf("%d\n", strlen(&arr));//6
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//5
}
运行结果：
例6：
int main()
{
int a[3][4] = { 0 };
printf("%zd\n", sizeof(a));//48-数组名a单独放在了sizeof内存，表示整个数组，sizeof(a)计算的是数组的大小，单位是字节
printf("%zd\n", sizeof(a[0][0]));//4-a[0][0]是数组的第一行第一个元素，这里计算的就是一个元素的大小，单位是字节
printf("%zd\n", sizeof(a[0]));//16 - a[0]是第一行这个一维数组的数组名，数组名单独放在了sizeof内部
//a[0]就表示整个第一行这个一维数组，sizeof(a[0])计算的整个第一行这个一维数组的大小
printf("%zd\n", sizeof(a[0] + 1));//4/8 - a[0]并非单独放在sizeof内部，也没有&,所以a[0]表示第一行这个一维数组首元素的地址
//也就是第一行第一个元素的地址
//a[0] <---> &a[0][0]
//a[0]+1 ---> &a[0][1]
printf("%zd\n", sizeof(*(a[0] + 1)));//4 - a[0] + 1是第一行第二个元素的地址，*(a[0] + 1))就是第一行第二个元素
//
printf("%zd\n", sizeof(a + 1));//4/8
//a 作为二维数组的数组名，并没有单独放在sizeof内部，也没有&，a就是数组首元素的地址，也就是第一行的地址， a 的类型是 int(*)[4]
//a+1 就是第二行的地址,类型是：int(*)[4]
//
printf("%zd\n", sizeof(*(a + 1)));//16 a+1是第二行的地址,*(a+1)就是第二行，计算的就是第二行的大小
//另外一个角度理解：*(a+1) -- a[1]
//sizeof(a[1]) - a[1]这个第二行的数组名，单独放在了sizeof内部，计算的是第二行的大小
printf("%zd\n", sizeof(&a[0] + 1));//4/8
//a[0]是第一行的数组名，&a[0]取出的是数组的地址，取出的是第一行这个一维数组的地址，类型就是int(*)[4]
//&a[0]+1 就是第二行的地址,类型就是int(*)[4]
printf("%zd\n", sizeof(*(&a[0] + 1)));//*(&a[0] + 1)得到的就是第二行，计算的就是第二行的大小
printf("%zd\n", sizeof(*a));//16
//a表示数组首元素的地址，也就是第一行的地址
//*a 就是第一行，也就相当于是第一行的数组名
//*a--> *(a+0) -- a[0]
//
printf("%zd\n", sizeof(a[3]));//16-不会越界，
//a[3] -- arr[0]
//int [4] int [4]
return 0;
}
运行结果：
指针进阶的内容就先更新到这里喽，学完之后多找一些题库刷刷会更好的掌握哦，之后会继续更新其他学习哦，希望大家支持！！！
扫一扫
774
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
