模拟qsort：函数指针、回调与泛型排序的底层实现

学C语言那阵子，指针把我虐得够呛。直到有一天，我照着库函数的实现思路，自己动手把qsort的底层逻辑完整模拟了一遍，很多之前一知半解的东西才真正串起来了。qsort是C标准库提供的排序函数，它的独特之处在于：一个函数能排序任意类型的数组，而这一切靠的是void指针和函数指针。今天这篇就完整记录一下我模拟qsort函数的过程，把函数指针、回调机制、泛型设计、内存操作这几个点一次讲透。如果你学过C语言但还没写过库函数级代码，或者正在准备面试，这篇应该能帮你省不少劲。

1. 先弄清楚：qsort到底解决了什么问题

1.1 从一次“万能排序”需求说起

先说个场景。假设你要排序一个int数组，写个冒泡排序很简单。几天后要排序double数组，怎么办？把冒泡排序复制一份，把int换成double，再改一遍比较逻辑。如果这个需求每周变一次，今天排字符串，明天排结构体，你手上就会堆满三四个几乎一模一样、只改了个类型的排序函数。

qsort的出现就是为了终结这种重复劳动。它的设计思路非常朴素：排序过程无非就是“比较两个元素”和“交换两个元素”，其中“比较”是唯一跟类型强相关的步骤。如果我把“怎么比”这个策略从函数里拿出来，交给调用者通过函数指针传入，剩下的比较、遍历、交换逻辑全部用通用的方式处理，就能写出一个“你给它什么类型，它就排什么类型”的万能排序函数。

这就是回调机制的核心思想，也是我个人认为C语言里最值得反复琢磨的设计模式之一。你不需要在qsort里知道元素的类型，你只需要知道每个元素占多大空间、相邻元素在内存里隔着多远，就可以通过地址偏移找到任意位置的元素，再交给你传入的比较函数去判断大小。

1.2 函数指针：把比较规则交出去

很多初学者一看到函数指针就头大，其实没那么玄乎。函数名本身就是函数的入口地址，函数指针就是用来保存这个地址、然后通过这个地址去调用函数的变量。它的声明语法确实有点绕：int (*compar)(const void *, const void *)。读法建议从中间往外读：先看到*compar，说明compar是个指针；往左遇到int，说明这个指针指向一个返回int的函数；右边括号里的两个参数都是const void *，说明被指向的函数接收两个常量空指针。

为什么要用const void *而不是int *或者char *？因为qsort是库函数，它根本不知道你要排什么类型。void *就是“任意类型指针”的意思，而const告诉比较函数：你这个比较操作只读不改，别把原始数据给我动了。这是库函数设计里的一个重要约定，也是很多面试官喜欢追问的细节。

类比一下，qsort就像是工厂里的一条流水线，它能处理规格不同的货品，但分拣规则由你制定。比较函数就是那张“分拣规则表”，你写好之后把规则表的地址交给流水线，流水线按你的规则一件件比对、摆放。规则表本身不是流水线的一部分，所以你想换规则，随时换。

2. 模拟前的功课：原型与内存细节

2.1 逐项拆解qsort的函数签名

先看一眼标准库里的qsort原型：

c复制void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

一共四个参数，每个都值得琢磨：

• base：数组的首地址。类型是void *，这是泛型的关键，任何类型的数组指针都能直接传进来，编译器不会报警。
• nmemb：数组中元素的个数。类型是size_t，也就是无符号整数，注意它永远不会是负数。
• size：每个元素占的字节数。比如int数组传sizeof(int)，结构体数组传sizeof(struct xxx)。传给qsort一个元素大小，它才能把void指针按“步长”往前走。
• compar：比较函数的指针，这是灵魂参数。

这段签名里有个极容易忽略的细节：既然有了base，为什么还要一个nmemb？因为C语言数组不会携带长度信息，你在函数内部无法通过指针反推数组大小，所以必须由调用者明确告知。同理，为什么有了base和nmemb，还要size？因为void *做不了指针运算，编译器不知道这个指针移动一格会跨多少个字节。如果把数组比作一栋楼，元素就是楼层，size就是层高，没有层高你连上下楼都没法走。

2.2 比较函数的返回契约与类型转换

比较函数是qsort的“裁判”，它的契约非常严格：

• 返回值大于0，表示第一个参数排在第二个参数后面；
• 返回值等于0，表示两个参数相等，相对顺序不保证；
• 返回值小于0，表示第一个参数排在第二个参数前面。

最常见的实现是直接相减。比如排int数组升序：

c复制int cmp_int(const void *a, const void *b)
{
    return *(int *)a - *(int *)b;
}

这里有一个新手特别容易踩的坑：a和b是const void *，不能直接解引用，必须先强转成const int *，再解引用。如果转成int *而不带const，编译器会警告，因为你在试图丢掉const限定。我建议一律写成const int *，养成好习惯。

另外，*(int *)a - *(int *)b这个写法在极端值下可能溢出。比如a指向的值是INT_MAX，b指向的值是-1，减法结果超出了int范围，行为未定义。标准库的实现比较严谨，一般会写成：

c复制int cmp_int(const void *a, const void *b)
{
    int ia = *(const int *)a;
    int ib = *(const int *)b;
    return (ia > ib) - (ia < ib);
}

这种写法先做两次布尔比较，再相减，结果只可能是-1、0、1，完全不会溢出，而且语义清晰。我后来的项目里凡是手写比较函数，都优先用这种模式。

2.3 字节交换：为什么不能直接赋值

qsort内部必然涉及交换元素。但是，拿到手的只是一个void *指针和元素大小，你怎么交换两个未知类型的变量？直接用一个临时变量显然不行，因为连类型都不知道，没法声明匹配的临时变量。更不能用memcpy直接覆盖，因为两个元素的内存区域可能重叠，还需要考虑交换的方向。

标准的做法是：把void *转成char *，然后逐字节交换。char类型在C标准里定义为一个字节大小，char *做算术运算时正好按字节移动。交换两个元素，本质就是交换它们在内存里的每个字节，跟元素是什么类型没关系。

我的swap实现如下：

c复制void swap_bytes(void *a, void *b, size_t size)
{
    char *pa = (char *)a;
    char *pb = (char *)b;
    while (size--) {
        char tmp = *pa;
        *pa++ = *pb;
        *pb++ = tmp;
    }
}

这里把size当作循环计数，每交换一个字节就把两个指针各自后移一格。注意循环条件是size--，先判断后递减，当size变成0时循环自然结束。这个函数只依赖字节地址，对类型一无所知，却能处理任意类型，这就是泛型编程在C语言里的朴素形态。

3. 动手模拟：从冒泡版到真正快排

3.1 第一版：冒泡排序理解框架

第一步，我用冒泡排序来搭框架，因为冒泡排序的代码结构最简单，能让你把注意力集中在“通过元素大小计算地址”和“通过函数指针调用比较函数”这两个关键动作上。

c复制void my_qsort_bubble(void *base, size_t nmemb, size_t size,
                     int (*compar)(const void *, const void *))
{
    if (nmemb <= 1) {
        return;
    }

    char *arr = (char *)base;

    for (size_t i = 0; i < nmemb - 1; ++i) {
        for (size_t j = 0; j < nmemb - 1 - i; ++j) {
            void *p1 = arr + j * size;
            void *p2 = arr + (j + 1) * size;
            if (compar(p1, p2) > 0) {
                swap_bytes(p1, p2, size);
            }
        }
    }
}

核心逻辑就两行。一行是用arr + j * size算出第j个元素的地址，另一行是compar(p1, p2)调用外部传入的比较函数。只要比较函数返回大于0，说明前一个元素应该在后一个元素后面，于是交换。

这段代码里有一个新手极其容易犯的错误：直接把base传进arr + j * size。base的类型是void *，C标准不允许对void *做算术运算，因为编译器不知道步长。所以必须先把base强转成char *，char保证是1字节，此时+ j * size才能得到正确的字节偏移。GCC提供了对void *按1字节运算的扩展，但严格符合标准的代码不应该这么写。

冒泡版本虽然能跑，但性能不行——O(n^2)的时间复杂度只能用来理解原理。接下来我把它升级成真正的快速排序。

3.2 第二版：标准快排分区实现

快速排序的核心是分区：选一个基准元素，把小于基准的元素挪到左边，把大于等于基准的挪到右边，然后递归处理左右两个子区间。我用的是Lomuto分区方案，代码写起来最简洁。

c复制void my_qsort(void *base, size_t nmemb, size_t size,
              int (*compar)(const void *, const void *))
{
    if (nmemb <= 1) {
        return;
    }

    char *arr = (char *)base;
    char *pivot = arr + (nmemb - 1) * size;
    size_t i = 0;

    for (size_t j = 0; j < nmemb - 1; ++j) {
        if (compar(arr + j * size, pivot) < 0) {
            if (i != j) {
                swap_bytes(arr + i * size, arr + j * size, size);
            }
            ++i;
        }
    }

    if (i != nmemb - 1) {
        swap_bytes(arr + i * size, pivot, size);
    }

    my_qsort(arr, i, size, compar);
    my_qsort(arr + (i + 1) * size, nmemb - i - 1, size, compar);
}

一步步拆解这段代码。首先取数组最后一个元素作为基准，指针pivot指向它。然后维护一个索引i，它标记“比基准小的元素应该放置的位置”。遍历前nmemb - 1个元素，只要某个元素比基准小，就把它交换到i的位置，然后i自增。循环结束时，i的左边全是小于基准的元素，右边全是大于等于基准的元素。最后把基准交换到i的位置，基准就归位了。

这里有个细节：为什么遍历时是j < nmemb - 1而不是j < nmemb？因为最后一个位置就是基准自己，它不需要和自己比较。而在交换基准归位时，if (i != nmemb - 1)的判断避免了基准和自己交换的无效操作。

递归调用时，左侧区间是[0, i)，元素个数是i。右侧区间从i + 1开始，元素个数是nmemb - i - 1。边界条件nmemb <= 1负责终止递归。

3.3 用四类数据验证模拟结果

模拟出来的函数能不能用，得拿数据说话。我写了四组测试，覆盖四种完全不同的数据类型，确保这个“泛型排序”真的通用。

第一组：int数组升序

c复制int cmp_int(const void *a, const void *b)
{
    int ia = *(const int *)a;
    int ib = *(const int *)b;
    return (ia > ib) - (ia < ib);
}

第二组：double数组降序

c复制int cmp_double_desc(const void *a, const void *b)
{
    double da = *(const double *)a;
    double db = *(const double *)b;
    return (db > da) - (db < da);
}

第三组：字符串数组按字典序

注意，这里数组的每个元素是一个char *指针，比较函数拿到的是“指向指针的指针”。

c复制int cmp_string(const void *a, const void *b)
{
    char * const *pa = (char * const *)a;
    char * const *pb = (char * const *)b;
    return strcmp(*pa, *pb);
}

第四组：结构体按成员排序

c复制typedef struct {
    int id;
    char name[32];
} Student;

int cmp_student(const void *a, const void *b)
{
    const Student *sa = (const Student *)a;
    const Student *sb = (const Student *)b;
    return (sa->id > sb->id) - (sa->id < sb->id);
}

测试主函数里，分别用my_qsort排序这四类数组，再打印结果验证。我的运行结果显示全部排序正确。这一步非常重要，它证明了模拟实现真的做到了“与类型无关”。

4. 实际踩坑与排查技巧实录

4.1 nmemb为0时冒泡越界

我第一次写冒泡版的时候，没加if (nmemb <= 1)这个判断。看起来好像没问题，因为空数组和单元素数组不需要排序，直接跳过外层循环就行。但问题出在size_t是无符号类型上。

当nmemb为0时，外层循环条件i < nmemb - 1里，nmemb - 1不是-1，而是无符号整数的最大值。这个循环会一直执行下去，疯狂访问数组之外的内存，轻则程序崩溃，重则产生难以复现的随机错误。

更隐蔽的是单元素数组的情况。如果nmemb为1，冒泡排序外层循环会执行i = 0这一轮，内层循环j < 0根本不会执行，所以勉强还不会越界。但如果你在冒泡排序里用了类似arr + nmemb * size的地址，那就是另一回事了。无论如何，排序函数第一行就该写上if (nmemb <= 1) return;，把边界情况直接堵死。这也是库函数设计时的常见防御性写法。

4.2 交换只换了一个字节的诡异现场

我第一次实现的swap函数是这样的：

c复制void swap_bad(void *a, void *b, size_t size)
{
    char tmp = *(char *)a;
    *(char *)a = *(char *)b;
    *(char *)b = tmp;
}

结果可想而知：排序出来的数组只有第一个字节是对的，其余字节纹丝不动。比如整数0x00000001和0x00000002交换后，只是最低字节变了，整体变成一个完全不合理的数。

这其实反映了一个认知问题：交换两个未知类型的对象，必须按对象占用的整个内存区域来操作，而不是按指针解引用一次就完了。你要把一个int整体换过去，就得交换sizeof(int)个字节。用循环逐字节交换，循环次数正好等于元素大小，这样才完整。

我在调试这个bug时，用gdb查看内存才直观看到问题所在。当时我在交换函数里打了一个断点，观察了a和b指向的内存，发现只有第一个字节变了。排查思路是：先确认比较函数是否被正确调用，再确认交换函数的循环次数是否正确。如果你也遇到类似诡异现象，建议先用gdb的x/16bx命令打印两个元素的内存内容，看看是哪些字节发生了变化。

4.3 比较函数里类型写错的连环坑

还有一种典型的翻车现场：比较函数内部强转类型写错。比如你排的是一个Student结构体数组，里面按id排序，但比较函数里写成了*(const int *)a。这样取出来的值就是结构体前4个字节，在特定结构体布局下，可能就是id，碰巧能排对；但一旦结构体里加了别的字段，或者字段顺序调整了，排序结果就乱了。

更危险的是如果结构体里有指针类型成员，你把指针强转成int再比较，不同位数的平台行为还不一样。这类bug极其隐蔽，因为编译不会报错，只有运行结果不对。排查方法只能是仔细审视比较函数里的类型转换到底对不对，最好在比较函数里加打印，把强转后的值和原始数据都打出来对比。

还有一种常见错误是字符串数组排序时，比较函数写成了这样：

c复制return strcmp((char *)a, (char *)b);

这是错的。因为数组里每个元素是char *，qsort传给比较函数的是元素的地址，也就是char **。你必须先解引用拿到char *，再传给strcmp。正确写法是前面展示的char * const *pa = a; strcmp(*pa, *pb);。这个坑几乎每个学qsort的人都会踩一次，我自己当年也是调了半天才醒悟过来。

4.4 函数指针调用的细节误解

有朋友问过我：在qsort内部，为什么是用compar(p1, p2)而不是(*compar)(p1, p2)？其实这两种写法在C语言里是等价的，compar作为函数指针，可以直接当函数名来调用，编译器会自动解引用函数指针。我个人更习惯写compar(...)，因为代码更简洁。

但有一个真正的细节是：compar这个参数本身不能被修改。你在排序函数内部可能会不小心写成compar = ...，这会导致编译错误，因为函数参数不是左值。如果你需要在内部保存它，用一个局部变量即可。这里不是什么大坑，但能让初学者区分清楚“函数指针变量”和“函数指针参数”这两个概念。

还有个容易混淆的点：使用qsort时，传入的是cmp_int，不是cmp_int()。前者是函数地址，后者是函数调用的结果。如果你写了my_qsort(arr, n, sizeof(int), cmp_int())，编译会报错，因为函数调用返回的是int，不是函数指针。这类拼写错误在IDE里可能看不出来，因为编译器报错信息比较隐晦。多看看报错信息里的“expected”和“got”部分，能很快定位。

4.5 练习时的建议：用空指针和大小量验证设计

还有一个我后来觉得特别有用的习惯：在测试模拟qsort时，专门抽出一些边界情况，比如数组长度为0、长度为1、所有元素相等、元素已经是逆序。这些边界条件能最大程度暴露排序实现中隐藏的越界和逻辑错误。

标准库里的qsort保证是稳定排序吗？不保证。C标准只要求它排序正确，不承诺稳定性。如果你的业务需要稳定排序，就得自己实现归并排序，或者用别的手段保证稳定性。模拟qsort时，你的实现同样不需要考虑稳定性问题，但你要清楚这一点，别在生产环境里硬套。

5. 从模拟qsort延伸出去的思考

5.1 用插入排序优化小区间

我上面实现的快速排序性能已经不错，但离标准库还有差距。一个常见的优化策略是：当递归区间长度小于某个阈值（比如10或16）时，改用插入排序。原因很简单，快速排序的递归调用开销在小数组上占比过高，而插入排序在小数组上的实际性能往往更好。

这个优化实现起来也不复杂。在my_qsort函数开头加一个判断：

c复制if (nmemb <= 16) {
    // 调用一个针对通用类型的插入排序
    return;
}

插入排序的代码跟冒泡排序一样，也可以通过char *指针和size参数实现通用化。感兴趣的话可以自己补上。标准库里的qsort在很多场景下还会使用“三数取中”法选择基准，避免最坏情况退化到O(n^2)。这些优化是很好的课余练习，但不影响你对qsort核心机制的理解。

5.2 泛型思想在C语言工程中的体现

模拟qsort最大的收获，不是学会了写排序，而是理解了C语言里“泛型”是怎么实现的。C语言没有C++的模板，也没有Java的泛型类，但通过void *、元素大小、函数指针这三个要素，照样写出了通用算法。

这个思想在C语言生态里随处可见。比如bsearch二分查找，原型跟qsort几乎一样，同样需要传入比较函数。再比如很多事件驱动框架里的回调函数机制，本质上都是在某个时机调用你传入的函数指针。理解了qsort，就等于拿到了理解这些库函数的一把钥匙。

我在实际工作中写C代码时，也经常借鉴这种模式。比如写一个通用的哈希表，或者一个通用的链表，底层只管理字节内存，具体类型操作全部通过函数指针暴露给外部。这样的代码可复用性极强，一套基础设施能服务好几个业务模块。

还有一点：模拟qsort让我认识到底层的内存操作必须非常谨慎。越界访问、类型强转错误、未定义行为，这些问题在普通的业务代码里可能看不出来，但在内存操作密集的泛型代码里会被放大。调试这类代码，gdb和AddressSanitizer是你最好的朋友。编译时加上-fsanitize=address，能让很多隐藏的内存错误现出原形。

最后分享一个我自己的体会。模拟qsort这个练习，常看常新。刚开始学指针的人可以只看冒泡版，理解函数指针怎么用；工作几年的人可以研究标准库的qsort是怎么在通用性和性能之间做权衡的。我后来每次回看这段代码，都能品出一些新东西。建议你在本地把这段代码亲手敲一遍，跑通四组测试数据，再试着加一些自己的优化，比如改成插入排序、加入三数取中。踩过几个坑之后再回头，你会发现自己对C语言的理解明显上了一个台阶。