目录
回调函数；
代码：
#include<stdio.h>
int add(int x, int y)
{
return x + y;
}
int jian(int x, int y)
{
return x - y;
}
int cheng(int x, int y)
{
return x * y;
}
int chu(int x, int y)
{
return x / y;
}
void jisuan(int(*pa)(int, int))
{
int x = 0;
int y = 0;
printf("请输入操作数：> ");
scanf("%d %d", &x, &y);
int ret = pa(x, y);
printf("%d\n", ret);
}
void menu()
{
printf("********1.add ***********\n");
printf("********2.jian ***********\n");
printf("********3.cheng***********\n");
printf("********4.chu ***********\n");
printf("********0.exit ***********\n");
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
do{
menu();
scanf("%d", &input);
switch (input)
{
case 1:
jisuan(add);
break;
case 2:
jisuan(jian);
break;
case 3:
jisuan(cheng);
break;
case 4:
jisuan(chu);
break;
case 0:
printf("退出\n");
break;
default:
printf("输入错误，请重新输入\n");
break;
}
} while (input);
return 0;
}代码分析：进入循环，出现菜单，输入input，进入switch语句，根据input选择case；进入case，不同的case里面传递了不同的函数指针，进入jisuan函数，输入操作数，通过函数指针调用相应的函数，得出计算结果；
运行结果：
qsort库函数介绍及实现；
冒泡排序；
代码：
#include<stdio.h>
int main()
{
int arr[] = { 2,5,7,8,10,1,3,9,4 };
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
int j = 0;
for (i = 0;i < sz - 1;i++)//总共sz-1次排序；
{
for (j = 0;j < sz - 1 - i;j++)//每次排序比较sz-1-i对数；
{
if (arr[j] > arr[j + 1])
{
int tem = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = tem;
}
}
}
for (i = 0;i < sz;i++)
{
printf("%d ", arr[i]);
}
return 0;
}代码分析：冒泡排序的思想主要是逐对比较，将最大（最小）的数排到最后，再将排名第二的数排到倒数第二位，如此循环；输入n个数，进行n-1次循环，拍好n-1个数，最后一个数自动归位；第一位数要比较n-1对数；第二位比较n-2对数；第m位比较n-m对数；如此循环；排序完之后打印各位数，观察排序效果；
运行结果：
qsort函数实现排序；
qsort介绍及使用；
比较两个数；
代码：
#include<stdio.h>
#include<stdlib.h>
int bidaxiao(const void* x, const void* y)//void*表示可以传任意指针类型，但使用的时候要强制转换成所要用的类型；
{
return *((int*)x) - *((int*)y);
}
int main()
{
int arr[] = { 2,5,7,8,10,1,3,9,4 };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), bidaxiao);//qsort 第一个参数是所要排的数组的首元素地址；第二个是元素的个数；第三个是每个元素的大小；
//第四个是要求的函数指针，这个函数要比较数组里两个元素的大小，返回>0 =0 <0;
int i = 0;
for (i = 0;i < sz;i++)
{
printf("%d ", arr[i]);
}
return 0;
}代码分析：首先建立一个数组，算出元素大小和元素个数；之后再写一个比较函数，函数的参数类型和返回类型参考上面；由于这里是比较两个数的大小，返回差值就满足函数的要求；现在形参是void* 型，所以做差时要先强制转换成int*型再解引用；写完函数后把函数的地址（函数名或者&函数名）传给qsort函数；使用qsort要添加头文件<stdlib.h>；之后打印出来观察效果；
运行结果：
比较字符；
代码：
#include<stdio.h>
#include<stdlib.h>
int bidaxiao(const void* x, const void* y)//void*表示可以传任意指针类型，但使用的时候要强制转换成所要用的类型；
{
return *((char*)x) - *((char*)y);
}
int main()
{
int arr[] = { 'a','d','c','s','b','k','x','z','y'};
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), bidaxiao);//qsort 第一个参数是所要排的数组的首元素地址；第二个是元素的个数；第三个是每个元素的大小；
//第四个是要求的函数指针，这个函数要比较数组里两个元素的大小，返回>0 =0 <0;
int i = 0;
for (i = 0;i < sz;i++)
{
printf("%c ", arr[i]);
}
return 0;
}代码分析：跟比较整数差不多，把比较函数改一下，由于字符再内存里是以整数形式存在的，所以指针类型强制转换为int* 或char* 类型效果一样；
运行结果：
比较结构体里面的内容；
代码：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>*///比较名字的前后，名字首字母a-z ；
struct student//结构体定义得放在最前面；
{
int age;
char name[100];
};
int bidaxiao(const void* x, const void* y)//void*表示可以传任意指针类型，但使用的时候要强制转换成所要用的类型；
{
return strcmp(((struct student*)x)->name, ((struct student*)y)->name);
}
int main()
{
struct student arr[] = { {10,"zhang"},{21,"bing"},{23,"sna"} };
int sz = sizeof(arr) / sizeof(arr[0]);
/*qsort(arr, sz, sizeof(arr[0]), bidaxiao);*///qsort 第一个参数是所要排的数组的首元素地址；第二个是元素的个数；第三个是每个元素的大小；
//第四个是要求的函数指针，这个函数要比较数组里两个元素的大小，返回>0 =0 <0;
qsort(arr, sz, sizeof(arr[0]), bidaxiao);
int i = 0;
for (i = 0;i < sz;i++)
{
printf("%d %s\n", arr[i].age, arr[i].name);
}
return 0;
}
代码分析：建立一个结构体数组，并对其进行初始化；建立一个比较函数，这里函数的内容是比较结构体里面的字符串的内容；用到strcmp函数，添加<string.h>头文件，strcmp是将两个字符串的首字母进行比较，返回>0 =0 <0;将qsort函数的参数补充完整，运行，打印，观察效果；
运行结果：
使用冒泡排序实现一个类似qsort函数的函数；
整数的比较；
代码：
#include<stdio.h>
int shuzi(const void* p1, const void * p2)
{
return (*((int*)p1) - *((int*)p2));
}
void SWAP(char* p1, char* p2,int size)
{
int i = 0;
for (i = 0;i < size;i++)
{
char x = *p1;
*p1 = *p2;
*p2 = x;
p1++;
p2++;
}
}
void bubllp(void* arr, int sz, int size,int(*shu)(const void*,const void*) )
{
int i = 0;
int j = 0;
for (i = 0;i < sz-1;i++)
{
for (j = 0;j < sz - 1 - i;j++)
{
if (shu((char*)arr + j * size, (char*)arr + (j + 1) * size)>0)
{
SWAP((char*)arr + j * size, (char*)arr + (j + 1) * size,size);
}
}
}
}
void test1()
{
int arr[] = { 2,5,7,8,10,1,3,9,4 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubllp(arr, sz, sizeof(arr[0]), shuzi);
int m = 0;
for (m = 0;m < sz;m++)
{
printf("%d ", arr[m]);
}
}
int main()
{
test1();
return 0;
}
代码分析：建立一个整形数组，写出一个比较函数和一个交换函数，比较函数还行跟qsort函数的比较函数一样，交换函数这里是以字符指针的形参接受，并且接受数组里每个内容的大小，交换的时候以一个字节的形式逐一交换，这样写的好处是可以不需要根据数组里内容的类型频繁改变形参类型；按照qsort函数的参数的输入形式输入到冒泡函数里，进入冒泡函数，按照冒泡函数的思想，建立两层循环，逐对比较；比较完后，打印出来观察效果；
运行结果：
结构体内容（这里是比较字符串内容）的比较；
代码：
int shuzi(const void* p1, const void* p2)
{
return strcmp((*(struct student*)p1).name, (*(struct student*)p2).name);//要注意运算符先算谁；
}代码分析：这里主要把整形比较的数组内容改成结构体；比较函数中运用strcmp实现字符串的比较；
运行结果：
