实现计算器：
下面是一般写法：（即通过各种各样的函数来一一实现）
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;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入两个操作数:>");
scanf("%d%d", &x, &y);
printf("%d\n",ADD(x, y));
break;
case 2:
printf("请输入两个操作数:>");
scanf("%d%d", &x, &y);
printf("%d\n", sub(x, y));
break;
case 3:
printf("请输入两个操作数:>");
scanf("%d%d", &x, &y);
printf("%d\n", mul(x, y));
break;
case 4:
printf("请输入两个操作数:>");
scanf("%d%d", &x, &y);
printf("%d\n", div(x, y));
break;
case 0:
printf("退出\n");
break;
default:
printf("选择错误\n");
break;
}
} while (input);
return 0;
}缺点是很明显的：比如增加计算器功能，就得多写几个函数，同时在选择结构上多加了很多行代码。
下面是通过函数指针数组来实现 ，
什么是函数指针数组：肯定是数组：数组的元素是函数指针，
记住：&add和add都表示函数的地址，没有任何区别
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 (*pfarr[5])(int, int) = { 0,ADD,sub,mul,div };
int ret = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
if (input >= 1 && input <= 4)
{
printf("请输入两个操作数:>");
scanf("%d%d", &x, &y);
ret = pfarr[input](x, y);
printf("%d\n", ret);
}
else if (input == 0)
{
printf("退出\n");
}
else
{
printf("选择错误\n");
}
} while (input);
return 0;
}回调函数
回调函数就是一个通过指针调用的函数，如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
下面简单的例子来理解一下
void print(char* str)
{
printf("hehe:%s", str);
}
void test(void (*p)(char*))
{
printf("test\n");
p("bit");
}
int main()
{
test(print);
return 0;
}解决函数冗余：比对最上面的程序，我们多次用到了下面代码内容
int x = 0;
int y = 0;
printf("请输入两个操作数:>");
scanf("%d%d", &x, &y);
printf("%d\n", pf(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 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("请输入两个操作数:>");
scanf("%d%d", &x, &y);
printf("%d\n", pf(x, y));
}
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;
}指向函数指针数组的指针
指向函数指针数组的指针是一个 指针 ；
指针指向一个 数组 ，
数组的元素都是 函数指针 ;
我们具体用qsort函数来理解一下指向函数指针数组的指针的使用，
之前我们学过冒泡排序
冒泡排序：
void bubble_sort(int arr[10], int sz)
{
int i = 0;
for (i = 0; i < sz - 1; i++)
{
//一趟冒泡排序
int j = 0;
for (j = 0; j <sz-i-1 ; j++)
{
if (arr[j] > arr[j +1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main()
{
int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr,sz);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}但是这个冒泡排序只能排整形，不能排浮点型和其他类型。说明我们的冒泡排序不能通用。
qsort函数的使用
qsort-库函数-排序
quick sort-算法实现的方法。
这个函数怎么用呢？我们先看看它有哪些参数
void qsort(void* base,
size_t num,
size_t width,
int (*compare)(const void* elem1, const void* elm2)
);base :start of target array;数组的起始位置。
num : Array size in elements;数组的大小
width : Element size in bytes;一个元素几个字节
compare :comparison function
总结：qsort函数的参数
第一个参数：待排序数组的首元素地址
第二个参数：待排序数组的元素个数
第三个参数：待排序数组的每个元素的大小——单位是字节
第四个参数：是函数指针，比较两个元素的函数的地址，这个函数使用者自己实现。
函数指针的两个参数是：待比较的两个元素的地址。
什么是void *，我们看下面的代码，可以发现pc会报警告，
有没有一种指针可以接收任意一种类型的元素的地址呢？，答案是有的，void *可以接收任意类型的地址，
int main()
{
int a = 10;
int* pa = &a;
char* pc = &a;
return 0;
}此时不会报错，void*，无具体的类型的指针。
void* p = &a;但是需要注意以下几点，你解引用无法知道要访问几个字节。所以下面代码会报错，所以void*无法进行解引用操作。同时也不能进行加减整数的操作。
int main()
{
int a = 10;
/*int* pa = &a;
char* pc = &a;*/
void* p = &a;
*p = 0;
return 0;
}比较函数的返回值是什么呢？
<0 : elem1 less than elem2
=0 : elem1 equivalent to elem2
>0 : elem1 greater than elem2
#include<stdlib.h>
int compare_int(const void* elem1, const void* elm2)
{
//比较两个整形值
return *(int*)elem1 - *(int*)elm2;
}
int main()
{
int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), compare_int);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}问题思考：我们写了比较函数传给了qsort函数，但是顺序是如何排呢？倒序还是升序
#include<stdlib.h>
int compare_int(const void* elem1, const void* elm2)
{
//比较两个整形值
return *(int*)elem1 - *(int*)elm2;
}
void test1()
{
int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), compare_int);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
int main()
{
test1();
return 0;
}比较浮点数
int compare_float(const void* elem1, const void* elm2)
{
//比较两个浮点值
/*return (*(float*)elem1 - *(float*)elm2);*/错误
return *(float*)elem1 - *(float*)elm2 ? *(float*)elem1 - *(float*)elm2 > 0 ? 1 : -1 : 0;
}
void test2()
{
float f[] = { 9.0, 5.0, 3.2, 6.3, 2.8, 5.7, 7.3 };
int sz = sizeof(f) / sizeof(f[0]);
qsort(f, sz, sizeof(f[0]), compare_float);
int j = 0;
for (j = 0; j < sz; j++)
{
printf("%f ", f[j]);
}
}
int main()
{
test2();
return 0;
}由于返回值要求是int型，浮点数强制类型转换肯定会损失精度，
我注释掉的是错误的，思考一下为啥错了
扫一扫
964
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
