如何在C语言中声明可接收任意深度嵌套指针的函数？

这个问题确实戳中了C语言没有泛型的痛点——要写一个能接收int*、int**、int***这类任意深度嵌套指针的函数，你一开始想到用void*配合深度参数dim的思路完全正确，这也是C里处理这类“动态类型”场景的标准路子。我来给你细化两种可行的实现方案：

一、硬编码层级的非通用实现（你思路的补全） #

如果你只需要处理有限的几层嵌套，直接像你写的那样，用if-else分支对应不同深度的类型转换就行，代码示例如下：

#include <stdio.h>

void myfunc(void* obj, int dim) {
    if (dim == 1) {
        int* myobj1 = (int*)obj;
        printf("处理1层指针：%d\n", *myobj1);
    } else if (dim == 2) {
        int** myobj2 = (int**)obj;
        printf("处理2层指针：%d\n", **myobj2);
    } else if (dim == 3) {
        int*** myobj3 = (int***)obj;
        printf("处理3层指针：%d\n", ***myobj3);
    }
    // 要支持更深的层级，继续加else if就行
}

int main() {
    int val = 42;
    int* p1 = &val;
    int** p2 = &p1;
    int*** p3 = &p2;

    myfunc(p1, 1);
    myfunc(p2, 2);
    myfunc(p3, 3);
    return 0;
}

这种写法的优点是直观，但缺点也很明显：没法处理无限深度的嵌套，每加一层都要手动加分支。

二、递归剥层的通用实现 #

如果要支持任意深度，最好的办法是用递归+指针的指针来动态“剥掉”外层指针，直到到达最后一层的int*。核心思路是：把每一层的指针都当成void**（因为所有指针的大小在主流系统里都是一致的），取出下一层的指针后深度减1，递归调用直到深度为1。

代码示例：

#include <stdio.h>

// 专门处理最终的int*的函数，把业务逻辑抽出来更清晰
void process_final_int(int* val) {
    printf("最终值：%d\n", *val);
}

void myfunc_recursive(void* obj, int dim) {
    if (dim == 1) {
        // 深度为1，直接转成int*处理
        process_final_int((int*)obj);
        return;
    }
    // 深度大于1，把当前指针转为void**，取出下一层的指针
    void** next_layer = (void**)obj;
    myfunc_recursive(*next_layer, dim - 1);
}

int main() {
    int val = 42;
    int* p1 = &val;
    int** p2 = &p1;
    int*** p3 = &p2;
    int**** p4 = &p3; // 随便加多少层都能处理

    myfunc_recursive(p1, 1);
    myfunc_recursive(p2, 2);
    myfunc_recursive(p3, 3);
    myfunc_recursive(p4, 4);
    return 0;
}

关键注意事项 #

• 必须保证dim和实际指针深度完全匹配：如果传入的dim比实际指针深度大，会导致非法内存访问（比如把int*当成void**解引用），直接触发未定义行为；如果dim比实际深度小，会提前终止递归，拿到的不是最终的int*。
• 仅适用于同类型嵌套指针：这个方案只处理指向int的嵌套指针，如果是混合类型（比如int*指向char**）就没法用了。
• 指针对齐问题：严格来说，从void*转换为void**需要保证原指针的对齐方式符合要求，但在x86、ARM等主流系统里，所有指针的对齐和大小都是一致的，一般不会有问题。

内容的提问来源于stack exchange，提问作者Anti Earth