入门学习计算机第十六天—指针进阶（二）
入门学习计算机第十六天—指针进阶（二）
编译器：Microsoft Visual Studio 2010
函数与指针
函数指针
函数指针-指向函数的指针-存放函数地址的一个指针
int Add(int x , int y)
{
return x+y;
}
int main()
{
int （*p）（int,int） = Add;
printf("%d\n",(*p)(20,50));
return 0;
}
输出的结果是70
void Print(char* str)
{
printf("%s\n", str);
}
int main()
{
void (*p)(char*) = Print;
(*p)("Hello");
return 0;
}
输出的结果是Hello
其中 p就是函数指针
看两个“有趣”的代码：
(*(void(*)())0)()
其实是一次函数调用过程。把0强制类型转换成：void(*)() 函数指针类型 - 0是一个函数的地址
之后调用0地址处的函数。
void(*signal(int,void(*)(int)))(int);
signal是一个函数声明，函数参数有两个，第一个是int,第二个是函数指针，该函数指针指向的函数的参数是int,返回类型是void
signal函数的返回类型也是一个函数指针；该函数指针指向的函数的参数是int,返回类型是void。
该函数是可以进行简化的：
typedef void(*pfun_t)(int);//函数指针的重命名与其他类型的重命名是不一样的，
//例如 typedef unsigned int uint;uint是重命名后的名字
//typedef void(*pfun_t)(int); pfun_t是重命名后的名字
pfun_t signal(int pfun_t);
函数指针数组
数组是一个存放相同类型数据的存储空间，比如：
int *arr[10]//数组的每个元素是int*
那要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义？
当有这么一个代码：
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(*pa)(int,int)= Add;//需要一个数组，这个数组可以存放4个函数的地址-函数指针的数组
int(*parr[4])(int,int) = {Add,Sub,Mul,Div};//如何使用？
int i = 0；
for(i = 0; i<4 ;i++)
{
printf("%d\n",parr[i](2,3));
}
return 0;
}
其中int（*parr[4]）(int,int)就是一个函数指针数组
已知代码：
char* my_strcpy(char* dest,const char* src)
1、写出函数指针pf，能够指向my_srtcpy
2、写出函数指针数组pfArr，能够存放4个my_strcpy的地址
char* (*pf)(char*,const char*);
char* (*pfArr[4])(char*,const char*);
用途：转移表
写一个计算器
最原始的方法：
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 menu()
{
printf("************* 1.加法 2.减法*********\n");
printf("************* 3.乘法 2.除法*********\n");
}
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;
}
这种写法太搓了，如果需要运算方法多了之后，case语句就会越写越多。
并且在打印两个操作数的步骤，出现次数太多了。
以下是修改后的：
int main()
{
int input = 0;
int x = 0;
int y = 0;
int (*parr[5])(int,int) ={0, Add ,Sub,Mul,Div};
do
{
menu();
printf("请选择想进行的运算：>");
scanf("%d",&input);
if(input>=1 && input<=4)
{
printf("请输入两个操作数：>");
scanf("%d%d",&x,&y);
printf("结果是:>%d\n",parr[input](x,y));
}
else if(input == 0)
{
printf("退出\n");
break;
}
else
{
printf("选择错误\n");
}
}while(input);
return 0;
}
指向函数指针数组的指针
指向函数指针数组的指针是一个指针，指针指向一个数组，数组的元素都是函数指针
int main()
{
int arr[10] = {0};
int (*p)[10] = &arr//取出数组的地址
int(*pfArr[4])(int,int);//pfArr是一个数组，函数指针的数组
int(*(*ppfArr)[4])(int,int)=&pfArr;//ppfArr是一个数组指针，指针指向的数组有4个元素，每一个元素的类似函数指针 int(*)(int,int)
return 0;
}
回调函数
回调函数就是一个通过函数指针调用的函数。如果把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，这就是回调函数。
在上述计算器代码中，有一直重复出现的代码：
printf("请输出两个操作数：>");
scanf("%d%d",&x,&y);
printf("结果是：%d\n",Mul(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;
...
冒泡排序：
数组中相邻的元素进行比较，如果不是想要的排序的效果，就交换两个元素的位置。
例子：要对数组进行升序排序
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 = 0;
tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
}
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;
}
输出的结果是
0 1 2 3 4 5 6 7 8 9
qsort函数:
void qsort (void* base, size_t num, size_t size,
int (*compar)(const void*,const void*));
//void* base 指向要排序的数组的第一个元素的指针
//size_t num 由 base 指向的数组中元素的个数
//size_t size 数组中每个元素的大小，以字节为单位
//int (*compar)(const void*,const void*) 用来比较两个元素的函数。
//需要引
以上述代码进行举例子：
int qsort_arr(const void* e1,const void* e2)
{
const int* ee1 = (int*)e1;
const int* ee2 = (int*)e2;
return (*ee1 >*ee2) -(*ee1 < *ee2);
}
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]),qsort_arr);
int i = 0;
for(i = 0; i<sz; i++)
{
printf("%d ",arr[i]);
}
return 0;
}
qsort对于任何类型的数据都可以进行排序。浮点型，字符串等等
因为void* 是无类型。
int main()
{
int a = 10;
int* pa =&a;
void* pc = &a;//是不会报错的
char b ='w';
void* pb =&b;//也不会报错
* pc =0;//会报错
p++;//也会报错
return 0;
}
void*类型的指针， 可以接收任意类型的地址
但是不能进行解引用操作，以及不能进行±操作
qsort函数排序浮点型数组
int qsort_arr(const void* e1,const void* e2)
{
const float* ee1 = (float*)e1;
const float* ee2 = (float*)e2;
return (int)((*ee1 >*ee2) -(*ee1 < *ee2));
}
int main()
{
float 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]),qsort_arr);
int i = 0;
for(i = 0; i<sz; i++)
{
printf("%lf ",arr[i]);
}
return 0;
}
输出的结果为：
用qsort函数排序结构体变量，用名字来排序
typedef struct Stu
{
char name[20];
int age;
}S;
int qsort_name(const void*e1,const void*e2)
{
//比较名字就是比较字符串
//比较字符串不能直接用><=比较，应该用strcmp函数
return strcmp(((struct Stu*)e1)->name,((struct Stu*)e2)->name);
}
int main()
{
S s [3]= {{"张三",30},{"李四",36},{"王五",20}};
int sz = sizeof(s)/sizeof(s[0]);
qsort(s,sz,sizeof(s[0]),qsort_name);
int i =0;
for(i = 0; i<sz; i++)
{
printf("%s ",s[i].name);
}
return 0;
}
输出的结果是：
用冒泡排序函数排序各种类型的数组,以结构体类型为例子：
#include 输出的结果：
重点在于冒泡排序函数的参数以及交换函数
void Swap(char* buf1,char* buf2,int width)
{
int i =0;
for(i=0; i<width; i++)
{//将宽度width传到函数的原因是：不同类型的元素的字节数不同，当两个元素要进行交换时，一个字节一个字节的进行交换，直到达到了一个元素的宽度。这就是完成了两个元素的位置交换
char tmp = *buf1;
*buf1 = *buf2;
*buf2 =tmp;
buf1++;
buf2++;
}
}
void Bubble_sort(void* base,int sz,int width,int(*compar)(const void*e1,const void*e2))
{ //void* base 可以接收任意类型的数组，并且指向了数组的第一个元素
//int sz 元素个数
//int width 因为不知道数组类型，所以在数组元素访问的时候，无法直接进行加减运算，但是如果知道每个元素的宽度，就可以跳过元素的宽度，访问下一个元素，单位是字节。
//int（*compar）(const void*e1,const void*e2) 函数指针，数组类型不一样，对应的比较大小的方式也不同，调用的函数也不同，所以类型也是void.
int i =0 ;
for(i = 0; i<sz-1; i++)
{
int j = 0;
for(j = 0;j<sz-1-i;j++)
{
//两个元素的比较
if(compar((char*)base+j*width,(char*)base+(j+1)*width) > 0)
{ //在冒泡排序中，每一趟的排序过程中，比较大小的元素是相邻的，又因为数组类型不知道，跳到下一个元素的时候，先让指针跳转一个字节，再乘以数组每一个元素的宽度，所以强制类型转化为char*,j*width就相当于跳过j个元素。(j+1)*width就等于跳过(j+1)个元素。
Swap((char*)base+j*width,(char*)base+(j+1)*width,width);
//当符合条件的两个相邻元素要进行交换位置时，就将两个元素的地址传给Swap函数。
}
}
}
}
这就是回调函数的引用。