C语言学习（指针5）

        今天我学习了函数指针的参数传递相关内容，包括qsort函数的冒泡排序实现以及自定义冒泡排序函数的编写，通过自定义比较函数和交换函数，可以实现对各种数据类型的排序操作下面我将分享今天的学习收获。

1. 函数指针作为参数传递

int add(int x, int y) 
{
    return x + y;  // 简单的加法函数
}

void B(int(*pa)(int,int))  // 接收函数指针作为参数
{
    int x = 0, y = 0;
    scanf("%d %d", &x, &y);  // 输入两个整数
    int r = pa(3, 2);        // 通过函数指针调用add函数
    printf("%d", r);         // 输出结果
}

int main()
{
    int(*pa)(int, int) = add;  // 定义函数指针指向add函数
    B(pa);                     // 将函数指针传递给B函数
}

2. qsort标准库函数使用

// 比较函数，比较两个元素的大小
// e1>e2 返回正数 e1==e2 返回0 e1<e2 返回负数
int compar(const void* e1, const void* e2)
{
    return(*(int*)e1 - *(int*)e2);  // 升序排序
}

void Print_arr1(int arr[], int sz)  // 打印数组函数
{
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
}

int main()
{
    int arr1[] = { 5,2,3,4,1,8,7,9,6,0 };
    size_t sz = sizeof(arr1) / sizeof(arr1[0]);  // 计算数组元素个数
    qsort(arr1, sz, sizeof(arr1[0]), compar);    // 调用qsort排序
    Print_arr1(arr1, sz);                        // 打印排序结果
}

3. 结构体与指针访问

struct stu
{
    char name[20];
    int score;
};

int main()
{
    struct stu s1 = { "zhangsan", 20 };
    struct stu* ps1 = &s1;  // 结构体指针

    printf("%s", (*ps1).name);  // 通过指针访问成员，等价于ps1->name
}

4. qsort排序结构体数组

struct stu
{
    char name[20];
    int score;
};

// 按姓名比较的结构体比较函数
int cmp_stu(const void* e1, const void* e2)
{
    return strcmp((*(struct stu*)e1).name, (*(struct stu*)e2).name);
}

void print_stu(struct stu arr[], int sz)  // 打印结构体数组函数
{
    for (int i = 0; i < sz; i++) 
    {
        printf("Name: %s, Score: %d\n", arr[i].name, arr[i].score);
    }
}

int main()
{
    struct stu arr[] = { {.name="zhang",.score=100}, {"wang",98}, {"liu",88} };
    size_t sz = sizeof(arr) / sizeof(arr[0]);  // 计算结构体数组大小
    qsort(arr, sz, sizeof(arr[0]), cmp_stu);   // 按姓名排序
    print_stu(arr, sz);                        // 打印排序结果
}

5. 按分数排序结构体

struct stu
{
    char name[20];
    int score;
};

// 按分数比较的结构体比较函数
int cmp_stu_age(const void* s1, const void* s2)
{
    return (*(struct stu*)s1).score - (*(struct stu*)s2).score;
}

int main()
{
    struct stu arr[] = { {"zhangming",260}, {"liuli",201} };
    size_t sz = sizeof(arr) / sizeof(arr[0]);  // 计算数组大小
    qsort(arr, sz, sizeof(arr[0]), cmp_stu_age);  // 按分数排序
}

6. 通用冒泡排序实现

// 交换两个字节的内容
void swap(char* b1, char* b2)
{
    *b1 = *b1 ^ *b2;
    *b2 = *b1 ^ *b2;  // 异或交换两个字符的值
    *b1 = *b1 ^ *b2;
}

// 整型比较函数
int cmp_int(const void* e1, const void* e2)
{
    return (*(int*)e1 - *(int*)e2);  // 升序
}

// 通用冒泡排序函数
void My_bubble(void* base, int sz, int width, int(*cmp_int)(const void* e1, const void* e2))
{
    for (int i = 0; i < sz - 1; i++)  // 外层循环控制轮次
    {
        for (int j = 0; j < sz - 1 - i; j++)  // 内层循环控制比较
        {
            // 比较相邻元素
            if (cmp_int((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
            {
                // 交换元素
                swap((char*)base + j * width, (char*)base + (j + 1) * width);
            }
        }
    }
}

// 打印数组函数
void Print_arr1(int arr[], int sz)
{
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

void test()
{
    int arr1[] = { 9,8,3,7,6,5,4,2,1,0 };
    int sz = sizeof(arr1) / sizeof(arr1[0]);  // 计算数组大小
    int width = sizeof(arr1[0]);              // 计算元素大小
    My_bubble(arr1, sz, width, cmp_int);      // 调用自定义冒泡排序
    Print_arr1(arr1, sz);                     // 打印排序结果
}

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

7. 不使用按位异或的通用冒泡排序

// 打印数组函数
void Print_arr(int arr[], int sz)
{
    for (int i = 0; i < sz; i++)
    {
        printf("%d ", arr[i]);
    }
}

// 交换任意类型的元素
void swap(char* e1, char* e2, int width)
{
    for (int i = 0; i < width; i++)  // 按字节交换
    {
        char tmp = *e1;
        *e1 = *e2;
        *e2 = tmp;
        e1++;
        e2++;
    }
}

// 整型比较函数
int cmp_arr(const void* e1, const void* e2)
{
    return(*(int*)e1 - *(int*)e2);
}

// 改进版通用冒泡排序
void My_bubble(void* base, int sz, int width, int(*cmp_arr)(const void* e1, const void* e2))
{
    for (int i = 0; i < sz - 1; i++)
    {
        for (int j = 0; j < sz - 1 - i; j++)
        {
            // char*的运算以字节为单位
            if (cmp_arr((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
            {
                swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
            }
        }
    }
}

void test1()
{
    int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);  // 计算数组大小
    int width = sizeof(arr[0]);             // 计算元素大小
    My_bubble(arr, sz, width, cmp_arr);     // 调用自定义冒泡排序
    Print_arr(arr, sz);                     // 打印排序结果
}

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