C语言如何模块化参数类型不同的函数实现逻辑复用？

这个需求完全可实现。你之前用void*写的代码跑不通，本质是犯了C语言泛型编程的典型错误：直接把void*强转成具体结构体指针访问成员时，编译器会固定按照目标结构体的内存布局计算偏移，而struct bNode和struct bNode2的key数组元素类型不同，Key和Key2的大小、成员偏移大概率不一致，强转后访问key数组的地址完全是错的，自然会出内存错误、逻辑跑飞。

这种方案类型安全、不依赖结构体隐式内存布局、后续扩展方便，不需要重复编写任何核心搜索逻辑。

1. 抽离公共节点头 #

两个节点结构体的前两个成员内存布局完全一致，先抽成公共头部，所有通用逻辑都可以通过公共头部访问，避免重复定义：

// 所有自定义节点结构体的前两个成员必须和该结构内存对齐
struct bNodeCommon {
    char nodeType;
    int numKeys;
};

2. 定义类型操作回调表 #

把搜索逻辑中和具体Key类型、节点类型绑定的差异操作抽成函数指针，不同节点类型各自实现对应逻辑即可，核心搜索函数完全不感知具体类型：

typedef struct {
    // 比较节点第idx位的key.id和目标id：返回值<0表示key.id < id，=0表示相等，>0表示key.id > id
    int (*cmpKey)(const void* node, int idx, int id);
    // 读取节点第idx位key存储的rrn值
    int (*getRrn)(const void* node, int idx);
    // 读取节点第idx位desc指向的子节点，返回堆上分配的节点指针
    void* (*readChild)(FILE* fp, const void* node, int idx);
} NodeOps;

3. 实现通用搜索函数 #

核心逻辑和你原来的searchID完全一致，所有类型相关操作都通过回调传入，不依赖具体结构体定义：

int searchID(FILE *indexFile, const void *node, int id, const NodeOps* ops) {
    const struct bNodeCommon* head = (const struct bNodeCommon*)node;
    if (head->nodeType == LEAF) {
        for (int i = 0; i < head->numKeys; i++) {
            if (ops->cmpKey(node, i, id) == 0) {
                return ops->getRrn(node, i);
            }
        }
    } else {
        int i = 0;
        while (i < head->numKeys && ops->cmpKey(node, i, id) < 0) {
            i++;
        }
        if (i < head->numKeys && ops->cmpKey(node, i, id) == 0) {
            return ops->getRrn(node, i);
        }
        void* child = ops->readChild(indexFile, node, i);
        int res = searchID(indexFile, child, id, ops);
        free(child); // 释放readNode类函数申请的堆内存，避免泄漏
        return res;
    }
    return -1;
}

4. 为两类节点实现对应回调 #

针对struct bNode，只需要实现三个简单的操作函数，绑定到操作表即可：

static int cmpBNodeKey(const void* node, int idx, int id) {
    const struct bNode* n = (const struct bNode*)node;
    return n->key[idx].id - id;
}

static int getBNodeRrn(const void* node, int idx) {
    const struct bNode* n = (const struct bNode*)node;
    return n->key[idx].rrn;
}

static void* readBNodeChild(FILE* fp, const void* node, int idx) {
    const struct bNode* n = (const struct bNode*)node;
    return readNode(fp, n->desc[idx]); // 复用你已有的bNode读取函数
}

const NodeOps bNodeOps = {
    .cmpKey = cmpBNodeKey,
    .getRrn = getBNodeRrn,
    .readChild = readBNodeChild
};

struct bNode2的回调实现逻辑完全一致，只需要把结构体类型换成bNode2、读取函数换成对应的readNode2即可，最终生成bNode2Ops操作表。

5. 调用方式 #

读取根节点时根据文件类型传入对应操作表即可，核心搜索逻辑完全复用：

// 处理第一种文件类型时
struct bNode* root1 = readNode(indexFile, rootRrn1);
int ret1 = searchID(indexFile, root1, targetId, &bNodeOps);
free(root1);

// 处理第二种文件类型时
struct bNode2* root2 = readNode2(indexFile, rootRrn2);
int ret2 = searchID(indexFile, root2, targetId, &bNode2Ops);
free(root2);

不建议用宏直接拼接生成两套搜索函数，这种写法调试成本极高，宏展开后的编译错误很难定位；也不建议利用结构体偏移直接强转指针访问key成员，这种写法依赖编译器的结构体对齐规则，换编译选项、跨编译器编译时很容易出现隐式bug。

内容的提问来源于stack exchange，提问作者Fróis