C语言重点突破（2）指针（三）

本章重点

1. 函数指针
2. 函数指针数组
3. 指向函数指针数组的指针
4. 回调函数

1.函数指针

首先可以明确的是，函数指针和数组指针的类型都是指针类型，用来存放地址的，数组指针存放数组的地址，而函数指针存放的便是函数的地址。

我们来看看函数指针是如何定义的

void test()
{
printf("hehe\n");
}
//下面pfun1和pfun2哪个有能力存放test函数的地址？
void (*pfun1)();
void *pfun2();

答案是：pfun1，首先*先与pfun1结合，说明它是一个指针，之后再与（）结合形成指向函数的指针，返回类型是void。 

2. 函数指针数组

前面我们已经学过指针数组，它是一个存放指针变量的数组，而函数指针数组就是存放函数指针的数组。

下面来看看它是如何定义的

有下面代码：

int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];

正确的答案是：parr1，parr1首先和【】结合（前面说过[]的优先级大于*）成为数组，而它的类型便是int (*)() 类型的函数指针。

简易实现计算器

相信各位在学习C语言的初期都尝试过实现一个加减乘除的简易计算器，但在学习完函数指针后，我们可以更加简单和高效的实现。

基本的思路，就是创建加减乘除对应的函数，然后利用条件选择语句（switch）根据所输入的input值来调用相应的函数，返回相应的值。

#include <stdio.h>
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 x, y;
int input = 1;
int ret = 0;
do
{
printf( "*************************\n" );
printf( " 1:add 2:sub \n" );
printf( " 3:mul 4:div \n" );
printf( "*************************\n" );
printf( "请选择：" );
scanf( "%d", &input);
switch (input)
{
case 1:
printf( "输入操作数：" );
scanf( "%d %d", &x, &y);
ret = add(x, y);
printf( "ret = %d\n", ret);
break;
case 2:
printf( "输入操作数：" );
scanf( "%d %d", &x, &y);
ret = sub(x, y);
printf( "ret = %d\n", ret);
break;
case 3:
printf( "输入操作数：" );
scanf( "%d %d", &x, &y);
ret = mul(x, y);
printf( "ret = %d\n", ret);
break;
case 4:
printf( "输入操作数：" );
scanf( "%d %d", &x, &y);
ret = div(x, y);
printf( "ret = %d\n", ret);
break;
case 0:
printf("退出程序\n");
breark;
default:
printf( "选择错误\n" );
break;
}
} while (input);
return 0;
}

我们发现，其实有好多的部分是重复冗余的，这样会增加代码的输入量，影响效率， 我们前面学到了函数指针数组，可不可以分别用指针指向对应的函数存放到一个数组里呢，然后我们根据输入的值调用对应下标的函数返回值即可，

#include <stdio.h>
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 x, y;
int input = 1;
int ret = 0;
int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
while (input)
{
printf( "*************************\n" );
printf( " 1:add 2:sub \n" );
printf( " 3:mul 4:div \n" );
printf( "*************************\n" );
printf( "请选择：" );
scanf( "%d", &input);
if ((input <= 4 && input >= 1))
{
printf( "输入操作数：" );
scanf( "%d %d", &x, &y);
ret = (*p[input])(x, y);
}
else
printf( "输入有误\n" );
printf( "ret = %d\n", ret);
}
return 0;
}

 这样一对比起来，利用函数指针数组会更加的简便。

3. 指向函数指针数组的指针

指向函数指针数组的指针是一个 指针,指针指向一个 数组 ，数组的元素都是函数指针.

下面来看看它是如何定义的

void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针pfun
void (*pfun)(const char*) = test;
//函数指针的数组pfunArr
void (*pfunArr[5])(const char* str);
pfunArr[0] = test;
//指向函数指针数组pfunArr的指针ppfunArr
void (*(*ppfunArr)[5])(const char*) = &pfunArr;
return 0;
}

做个简单了解即可，如果要深究的话过于复杂，感兴趣的小伙可以自行了解哦。

4. 回调函数

何为回调函数？回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

关于回调函数的例子，最典型的是qsort函数

qsort函数是C语言标准库中的一个函数，用于对数组进行快速排序。使用它时，需要传入四个参数：

void* base：是需要排序数组的起始地址。

size_t num：需要排序的元素个数。

size_t size：需要比较元素的单个大小，单位是字节。

int (*compar)(const void* ,const void*)：参数compare为排序比较函数的指针，用于指定排序规则。

我们来看看它是如何使用的

#include <stdio.h>
//qosrt函数的使用者得实现一个比较函数
int int_cmp(const void * p1, const void * p2)
{
return (*( int *)p1 - *(int *) p2);
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
int i = 0;
qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
{
printf( "%d ", arr[i]);
}
printf("\n");
return 0;
}

模拟实现qsort函数（冒泡排序）

 首先介绍一下冒泡排序的思想

冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来，直到没有任何一对数字需要交换为止。

冒泡排序的基本思想是，将待排序的元素看作为竖向排列的气泡，在每一轮排序中，从下往上依次比较相邻的两个气泡的大小关系，并根据需要交换相邻的两个元素位置，大的元素就像气泡一样往上“飘”。

冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。

下面是冒泡排序的C语言实现代码：

void bubble_sort(int arr[], int len) {
    int temp;
    for (int i = 0; i < len - 1; i++) {  // 外层循环控制排序轮数
        for (int j = 0; j < len - i - 1; j++) {  // 内层循环控制每轮排序中的比较次数
            if (arr[j] > arr[j + 1]) {  // 如果前面的元素大于后面的元素，交换它们的位置
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

调用bubble_sort函数可对一个整型数组进行升序排列。

再来，我们介绍一下void* 的作用

void* 是C语言中的一个指针类型，通常称之为“无类型指针”。它可以指向任意类型的数据，因为所有的类型都可以通过指针进行访问和操作。

由于 void* 没有指定数据类型，因此无法对其进行解引用操作。为了访问指针所指的数据，我们要先将 void* 指针进行类型转换，然后才能访问其所指向的数据。

在C语言中，void* 经常用于函数参数和返回值的类型。例如，如果一个函数需要处理不同类型的数据，可以使用 void* 作为参数类型，然后在函数内部使用类型转换将参数转换为所需的类型。同样地，如果一个函数需要返回不同类型的数据，也可以使用 void* 作为返回值类型。

基于void*的特性，使得qsort可以排序任意类型的元素。

下面我们来开始实现，首先qsort函数是需要一个比较函数的，如果p1大于p2就返回一个大于0的值，否则返回一个小于0的值，相等则返回0.

我们要定义一个比较函数，注意这里的类型转换，因为比较函数cmp的参数类型是固定的，不能改变的，但void*的类型相减跳过多少个字节也取决于qsort里数组的参数类型（可以看成qsort是不知道传入的参数类型是什么的），所以在里面统一强转成整型（因为例子是整型数组）。

int int_cmp(const void * p1, const void * p2)
{
return (*( int *)p1 - *(int *) p2);
}

 有了比较函数，我们还得有比较完成后的交换函数，我们基于最简单的交换思路来写，关于参数，p1，p2肯定得有，除此之外，我们还得需要一个单个元素大小的参数，这里我们要细讲一下。

前面我们说过，qsort是不知道我们传入的参数类型的，正因如此，它才能比较任意类型的数据。举个例子，整型数据在内存里占4个字节，加1跳过四个字节（交换必然涉及到加减操作），但qsort可不知道传入的数据类型，如果采用整型的加一，但比较数据是字符类型呢？（字符在内存中占一个字节），这样的话比较出来的结果就大不相同了。所以要交换的话，我们采用一个字节一个字节的进行交换，这样方便所有的类型，自然而然就转换成char类型的进行交换就行了。

void _swap(void *p1, void * p2, int size)
{
int i = 0;
for (i = 0; i< size; i++)
{
char tmp = *((char *)p1 + i);
*(( char *)p1 + i) = *((char *) p2 + i);
*(( char *)p2 + i) = tmp;
}
}

基于上面的函数，我们开始写基于冒泡排序的qsort函数

void bubble(void *base, int count , int size, int(*cmp )(void *, void *))
{
int i = 0;
int j = 0;
for (i = 0; i< count - 1; i++)
{
for (j = 0; j<count-i-1; j++)
{
if (cmp ((char *) base + j*size , (char *)base + (j + 1)*size) > 0)
{
_swap(( char *)base + j*size, (char *)base + (j + 1)*size, size);
}
}
}
}

测试函数

int main()
{
int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
//char *arr[] = {"aaaa","dddd","cccc","bbbb"};
int i = 0;
bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
{
printf( "%d ", arr[i]);
}
printf("\n");
return 0;
}