指针进阶（3）指向函数指针数组的指针 回调函数 qsort函数 模拟实现qsort（采用冒泡的方式）

七、指向函数指针数组的指针

int add(int x,int y)
{
     return x+y;
}
int main()
{
         int arr[10]={0};
         int(*p)=&arr;//p是数组指针
         int* arr[5];
         int*(*p2)[5]=&arr2;
               
         //函数指针
         int (*pf)(int,int)=&add;
         //函数指针数组
         int(*pfarr[4])(int,int);
         int(*(*p3)[4])(int,int)=&pfarr;//p3是指向函数指针数组的指针
}

int add(int a, int b)
{
           return a + b; 
}
int sub(int a, int b) 
{
           return a - b; 
}
int mul(int a, int b) 
{
           return a*b; 
}
int div(int a, int b) 
{
           return a / b; 
}

int main()
{
    int(*pfarr[4](int,int))={add,sub,mul,div};//7 -1 12 0
    int(*(*p3)[4])(int,int)=&pfarr;
    for(int i=0;i<4;i++)
    {
         int ret=(*p3)[i](3,4);
         printf("%d\n",ret);
    }
}

八、 回调函数 

 回调函数就是一个通过函数指针调用的函数。

void test()//回调函数
{
    printf("hehe"\n);
}
void print_hehe(void(*p)())
{
    if(1)
    p();
}
int main()
{
    print_hehe(test);
}

int add(int a, int b) //回调函数
{
    return a + b; 
}
int sub(int a, int b) //回调函数
{
    return a - b;  
}
int mul(int a, int b) //回调函数
{
    return a*b; 
}
int div(int a, int b)  //回调函数
{
    return a / b; 
}
void calc(int(*pf)(int,int))
{
    int x, y;
    int ret = 0;
    printf( "输入操作数：" );
    scanf( "%d %d", &x, &y);
}
int main()
{
    int input;
    do
    {
        printf( "***********************\n" );
        printf( " 1:add           2:sub \n" );
        printf( " 3:mul           4:div \n" );
        printf( "*0:exit****************\n" );
        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");
              breark;
        default:
              printf( "选择错误\n" );
              break;
       }
     } while (input);
    
}

 qsort函数的使用： 

 qsort是一个库函数，基于快速排序算法实现的一个排序的函数，任意类型数据都可以排序

 qsort(待排数据起始位置，数组元素个数，一个元素字节大小，比较函数 );

 比较函数(待比较的两个元素的地址)，int cmp_int(const void*e1,const void*e2);

qsort函数的使用

#include<stdlib.h>
#include<string.h>
//排序整型数据用> <
//排序的结构体数据：可能不方便直接使用< >比较
//使用者根据实际情况，提供一个函数，实现2个数据的比较
int cmp_int(const void*e1,const void*e2)
{
     // if(*(int*)e1>*(int*)e2)
     // return 1;
     // else if if(*(int*)e1==*(int*)e2)
     // return 0;
     // else return -1;
     return (*(int*)e1-*(int*)e2);//void强制类型转换为元素的地址的类型
}
void test2()
{
    int arr[]={9,8,7,6,5,4,3,2,1,0};
     //排序为升序
     int sz=sizeof(arr)/sizeof(arr[0]);
     qsort(arr,sz,size(arr[0]),cmp_int);
     print_arr(arr,sz);
}
void bubble_sort(int arr[],int sz)//冒泡排序只能排序整型数组
{
   for(int i=0;i<sz-1;i++)
   {
       for(int j=0;j<sz-1-i;j++)
       {
            if(arr[j]>arr[j+1])
            { 
                int t=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=t;
            }
       }
    }
}
void print_arr(int arr[],int sz)
{
     for(int i=0;i<sz;i++)
     {
          printf("%d ",arr[i]);
     }
     printf("\n");
}
void teat1()
{
     int arr[]={9,8,7,6,5,4,3,2,1,0};
     //排序为升序
     int sz=sizeof(arr)/sizeof(arr[0]);
     bubble_sort(arr,sz);
     print_arr(arr,sz);
}
struct stu
{
    char name[20];
    int age;
    double score;
};
int cmp_stu_by_age(const void*e1,const void*e2)
{
    return (((struct stu*)e1)->age-((struct stu*)e2)->age);
}
int cmp_stu_by_name(const void*e1,const void*e2)
{
    return strcmp(((struct stu*)e1)->name,((struct stu*)e2)->name);
}
void teat3()//使用qsort排序结构体
{
   struct stu arr[3]={{"zhangsan",20,55.5},{"lisi",30,88.0},{"wangwu",10,90.0}};
   int sz=sizeof(arr)/sizeof(arr[0]);   
   qsort(arr,sz,sizeof(arr[0]),cmp_stu_by_age);//wangwu zhangsan lisi
   qsort(arr,sz,sizeof(arr[0]),cmp_stu_by_name);//lisi wangwu zhangsan
}
int main()
{
    test1();
    test2();
}

 模拟实现qsort（采用冒泡的方式）

void swap(char* buf1, char* buf2, int width)
{
    for (int i = 0; i < width; i++)
    {
        char t = *buf1;
        *buf1 = *buf2;
        *buf2 = t;
        buf1++;
        buf2++;
    }
}
int cmp_int(const void* e1, const void* e2)
{
    return (*(int*)e1 - *(int*)e2);//void强制类型转换为元素的地址的类型
}
void bubble_sort(void* base, int num, int width,int(*cmp)(const void* e1, const void* e2))
{
    for (int i = 0; i < num - 1; i++)
    {
        for (int j = 0; j < num - 1 - i; j++)
        {
            //if(arr[j]>arr[j+1])比较            
            if (cmp((char*)base + (j)*width, (char*)base + (j + 1) * width) > 0)
            {
                //交换
                // int t=arr[j];
                // arr[j]=arr[j+1];
                // arr[j+1]=t;
                swap((char*)base + (j)*width, (char*)base + (j + 1) * width,width);
            }
        }
    }
}
void print_arr(int arr[], int sz)
{
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}
int main()
{
    int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);//0 1 2 3 4 5 6 7 8 9
    print_arr(arr, sz);
}