本文共 7232 字，大约阅读时间需要 24 分钟。

入门学习计算机第十六天—指针进阶（二）

编译器：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
   
    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
   

输出的结果是

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

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

输出的结果为：

用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

输出的结果是：

用冒泡排序函数排序各种类型的数组,以结构体类型为例子：

#include 
   
    #include 
    
     #include 
     
      struct Stu{
      char name[20];   int age;};void Swap(char* buf1,char* buf2,int width){
       int i =0;	for(i=0; i
      
       *ee2) -(*ee1 < *ee2);}int qsort_name(const void*e1,const void*e2){
   	//比较名字就是比较字符串	//比较字符串不能直接用><=比较，应该用strcmp函数	return strcmp(((struct Stu*)e1)->name,((struct Stu*)e2)->name);}void Bubble_sort(void* base,int sz,int width,int(*compar)(const void*e1,const void*e2)){
      int i =0 ;   for(i = 0; i
       
         0)		  {
   		    //交换			  Swap((char*)base+j*width,(char*)base+(j+1)*width,width);		  		  }	  }      }}int main(){
   	struct Stu s[5]={
   {
   "陈狗蛋",22},{
   "矮冬瓜",13},{
   "高富帅",30},{
   "白富美",18},{
   "矮穷搓",38}};	//int arr[10] = {9,7,8,5,3,2,4,1,6,0};	int sz = sizeof(s)/sizeof(s[0]);	Bubble_sort(s,sz,sizeof(s[0]),qsort_name);	int i = 0;	for(i = 0 ;i
       
      
     
    
   

输出的结果：

重点在于冒泡排序函数的参数以及交换函数

void Swap(char* buf1,char* buf2,int width){
           int i =0;	for(i=0; i
   
     0)		  {
    //在冒泡排序中，每一趟的排序过程中，比较大小的元素是相邻的，又因为数组类型不知道，跳到下一个元素的时候，先让指针跳转一个字节，再乘以数组每一个元素的宽度，所以强制类型转化为char*,j*width就相当于跳过j个元素。(j+1)*width就等于跳过(j+1)个元素。			  Swap((char*)base+j*width,(char*)base+(j+1)*width,width);		     //当符合条件的两个相邻元素要进行交换位置时，就将两个元素的地址传给Swap函数。		  }	  }      }}
   

这就是回调函数的引用。

转载地址：https://blog.csdn.net/xiaotangyu7dong/article/details/116136416 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！