【指针进阶08】回调函数

回调函数

一个通过函数指针调用的函数
回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的， 用于对该事件或条件进行响应。

code1

#include<stdio.h>
void print(char* str)
{
    prinft("hehe:%s", str);
}

void test(void(*p)(char*))
{
    printf("test\n");
    p("bit");
}


int main()
{
    test(print);
    return 0;
}

test函数响应main函数的调用，print函数响应test函数调用。

code2

这是一个最简单的整型数据（int）冒泡排序

#include<stdlib.h>
#include<string.h>
void BubbleSort(int arr[], int sz)
{
    //确定冒泡排序的趟数
    int i = 0;
    for (i = 0; i < sz - 1; i++)
    {
        int flag = 1;//假设这一趟要排序的数据已经有序
    //每一趟冒泡排序
        int j = 0;
        for (j = 0; j < sz - 1 - i; j++)
        {
            if (arr[j] < arr[j + 1])
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
                flag = 0;//本趟排序的数据不完全有序
            }
        }
        if (flag == 1)
        {
            break;
        }
    }
}

int main()
{
    int arr[10] = { 2,5,6,7,8,9,4,1,3,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    Bubble_sort(arr,sz);
    return 0;
}

mian函数调用BubbleSort函数。

code3（整型冒泡）

实现bubble_sort函数的程序员，他是否知道未来排序的数据类型 - 不知道
那程序员也不知道，待比较的两个元素类型

int cmp_int(const void* e1, const void* e2)
{
    //比较两个整型值的
    return *(int*)e1 - *(int*)e2;
}

void Swap(char* buf1, char* buf2, int width)
{
    int i = 0;
    for (i = 0; i < width; i++)
    {
        char tmp = *buf1;
        *buf1 = *buf2;
        *buf2 = tmp;
        buf1++;
        buf2++;
    }
}

void bubble_sort(void* base, int sz, int width, int(*cmp)(void* e1, void* e2))
{
    int i = 0;
    //趟数
    for (i = 0; i < sz - 1; i++)
    {
        //每一趟比较的对数
        int j = 0;
        for (j + 0; j < sz - 1 - i; j++)
        {
            //两个元素的比较
            if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
            {
                //交换
                Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
            }
        }
    }
}

void test4()
{
    int arr[10] = { 2,5,6,7,8,9,4,1,3,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
    //使用buubble_sort的程序员一定知道自己排序的是什么数据
    //就应该知道如何比较待排序数组中的元素
}

int main()
{
    test4();
    return 0; 
}

main函数调用test4函数，test4函数调用bubble_sort函数，bubble_sort再调用cmp_int和Swap函数。
如果想要排序其他数据类型自己写一个比较函数就行了。

code4（冒泡排序结构体）

声明结构体

struct  Stu
{
    char name[20];
    int age;
};

int cmp_stu_by_age(const void* e1, const void* e2)
{
    return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

比较名字就是比较字符串
字符串不能直接用><=来比较，应该用strcmp函数

int cmp_stu_by_name(const void* e1, const void* e2)
{
    return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

void test5()
{
    struct Stu s[3] = { {"zhangsan",20},{"lisi",30},{"wangwu",10} };
    int sz = sizeof(s) / sizeof(s[0]);
    bubble_sort(s, sz, sizeof(s[0]),cmp_stu_by_age);
    bubble_sort(s, sz, sizeof(s[0]), cmp_stu_by_name);
}

bubble_sort ( );
第一个参数：待排序数组的收元素地址
第二个参数：待排序数组的元素个数
第三个参数：待排序数组的每个元素的大小-单位是字节
第四个参数：是指针函数，比较两个元素所用函数的地址-这个函数使用者自己实现函数指针的两个参数是：待比较的两个元素的地址

int main()
{
    test5();
    return 0;
}

qsort - 可以排序任意类型的数据

那么，他是怎么做到的呢？

qsort - 库函数 - 排序

void qsort(void *base,size_t num, size_t width, int(*cmp)(const void* e1, const void* e2));

比较浮点型

int cmp_float(const void* e1, const void* e2)
{
    /*if( *(float*)e1 == *(float*)e2）;
         return 0;
    else if( *(float*)e1 > *(float*)e2）;
         return 1;
    else ( *(float*)e1 < *(float*)e2）;
         return -1;*/
    return ((int)(*(float*)e1 - *(float*)e2));
}

code5（整型快排）

void test1()
{
    int arr[10] = { 2,5,9,7,8,4,6,1,3,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    qsort(arr, sz, sizeof(arr[0]), cmp_int);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
}

code6（浮点型快排）

void test2()
{
    float f[] = { 9.5, 5.2, 4.3, 9.4, 7.8 };
    int sz = sizeof(f) / sizeof(f[0]);
    qsort(f, sz, sizeof(f[0]), cmp_float);
    int j = 0;
    for (j = 0; j < sz; j++)
    {
        printf("%.2f ", f[j]);
    }
}

code7（结构体快排）

void test3()
{
    struct Stu s[3] = { {"zhangsan",20},{"lisi",30},{"wangwu",10} };
    int sz = sizeof(s) / sizeof(s[0]);
    qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);  
}

int main()
{
    test1();
    test2();
    test3();
    return 0;
}

void * 类型的指针的使用

code8

int main()
{
    int a = 10;
    int* pa = &a;
    *pa = 0;
    
    void* p = &a;
    *p = 0;

    return 0;
}

上面这段代码有问题吗？有的，这里涉及到一个知识点

    int a = 10;
    int* pa = &a;
    *pa = 0;

这部分肯定是没问题的，指针都学这么多了，还有问题就是你的问题了！
那么问题就出现在后面了

    void* p = &a;
    *p = 0;

void * 类型的指针 可以接收任意类型的地址
void * 类型的指针 不能进行解引用操作
void * 类型的指针不能进行加减整数的操作

预告

下一章 - - - 指针和数组笔试题解析（大量干货）