C语言中能否用单个包装器适配两个不同签名的函数？

问题背景 #

我需要定义包装器函数扩展被包装函数的功能。约20个函数的签名如下：

coco_problem_t f_<function_name>_bbob_problem_allocate(
   const size_t function,
   const size_t dimension,
   const size_t instance,
   const long rseed,
   const char *problem_id_template,
   const char *problem_name_template)

我通过定义函数指针类型并传入包装器，可轻松实现这类函数的包装，步骤如下：

• 定义用于传入包装器的函数指针类型

typedef coco_problem_t *(*coco_problem_bbob_allocator_t)(
  const size_t function,
  const size_t dimension,
  const size_t instance,
  const long rseed,
  const char *problem_id_template,
  const char *problem_name_template);

• 包装器函数签名

coco_noisy_problem_t *coco_problem_allocate_bbob_wrap_noisy(
    coco_problem_bbob_allocator_t coco_problem_bbob_allocator,
    const size_t function,
    const size_t dimension,
    const size_t instance,
    const long rseed,
    const char *problem_id_template,
    const char *problem_name_template );

但有两个函数签名略有不同：

• 第一个多一个double类型参数：

coco_problem_t f_<function_name>_bbob_problem_allocate(
     const size_t function,
     const size_t dimension,
     const size_t instance,
     const long rseed,
     const double conditioning,
     const char *problem_id_template,
     const char *problem_name_template)

• 第二个多一个size_t类型参数：

coco_problem_t f_<function_name>_bbob_problem_allocate(
     const size_t function,
     const size_t dimension,
     const size_t instance,
     const long rseed,
     const size_t n_peaks,
     const char *problem_id_template,
     const char *problem_name_template)

目前我可通过定义两个额外函数指针类型和对应包装器解决，但该方式繁琐不够优雅。作为C语言新手，我想知道是否可通过类型联合等方式，用单个包装器适配这两个特殊函数。

解决方案：联合+通用参数传递实现单包装器适配 #

在C语言中，可以通过函数指针联合配合包装器的通用参数传递，实现单个包装器适配不同签名的函数，核心是用联合容纳不同类型的函数指针，再通过类型标识区分调用逻辑。

步骤1：定义包含所有函数指针类型的联合 #

先把三种函数指针类型统一放入一个联合中：

// 基础函数指针类型
typedef coco_problem_t *(*coco_problem_bbob_allocator_t)(
    const size_t function,
    const size_t dimension,
    const size_t instance,
    const long rseed,
    const char *problem_id_template,
    const char *problem_name_template);

// 带double参数的函数指针类型
typedef coco_problem_t *(*coco_problem_bbob_allocator_with_double_t)(
    const size_t function,
    const size_t dimension,
    const size_t instance,
    const long rseed,
    const double conditioning,
    const char *problem_id_template,
    const char *problem_name_template);

// 带size_t参数的函数指针类型
typedef coco_problem_t *(*coco_problem_bbob_allocator_with_size_t_t)(
    const size_t function,
    const size_t dimension,
    const size_t instance,
    const long rseed,
    const size_t n_peaks,
    const char *problem_id_template,
    const char *problem_name_template);

// 定义函数指针联合
typedef union {
    coco_problem_bbob_allocator_t base;
    coco_problem_bbob_allocator_with_double_t with_double;
    coco_problem_bbob_allocator_with_size_t_t with_size_t;
} coco_problem_bbob_allocator_union_t;

步骤2：定义通用包装器函数 #

包装器需要额外两个参数：一个标识函数类型的枚举，以及一个void*类型的通用参数（用来传递double或size_t类型的额外参数）。

首先定义类型标识枚举：

typedef enum {
    ALLOCATOR_TYPE_BASE,
    ALLOCATOR_TYPE_WITH_DOUBLE,
    ALLOCATOR_TYPE_WITH_SIZE_T
} allocator_type_t;

然后实现通用包装器：

coco_noisy_problem_t *coco_problem_allocate_bbob_wrap_generic(
    coco_problem_bbob_allocator_union_t allocator,
    allocator_type_t type,
    const size_t function,
    const size_t dimension,
    const size_t instance,
    const long rseed,
    void *extra_param, // 传递额外参数的通用指针
    const char *problem_id_template,
    const char *problem_name_template) {

    coco_problem_t *base_problem = NULL;

    // 根据类型调用对应分配函数
    switch (type) {
        case ALLOCATOR_TYPE_BASE:
            base_problem = allocator.base(function, dimension, instance, rseed, problem_id_template, problem_name_template);
            break;
        case ALLOCATOR_TYPE_WITH_DOUBLE:
            // 将void*转换为double*后取值
            base_problem = allocator.with_double(function, dimension, instance, rseed, *(double*)extra_param, problem_id_template, problem_name_template);
            break;
        case ALLOCATOR_TYPE_WITH_SIZE_T:
            // 将void*转换为size_t*后取值
            base_problem = allocator.with_size_t(function, dimension, instance, rseed, *(size_t*)extra_param, problem_id_template, problem_name_template);
            break;
        default:
            // 处理无效类型，返回NULL或自定义错误
            return NULL;
    }

    // 这里加入你的包装逻辑，比如将base_problem转换为coco_noisy_problem_t
    if (!base_problem) {
        return NULL;
    }
    coco_noisy_problem_t *noisy_problem = /* 你的包装/转换代码 */;
    return noisy_problem;
}

步骤3：调用通用包装器示例 #

调用不同类型函数时，只需初始化对应联合成员，传入正确的类型标识和额外参数：

• 调用基础类型函数

coco_problem_bbob_allocator_union_t alloc;
alloc.base = f_some_base_function_bbob_problem_allocate;

coco_noisy_problem_t *prob = coco_problem_allocate_bbob_wrap_generic(
    alloc,
    ALLOCATOR_TYPE_BASE,
    1, 10, 1, 42,
    NULL, // 基础类型无额外参数
    "id_template", "name_template");

• 调用带double参数的函数

double conditioning = 100.0;
coco_problem_bbob_allocator_union_t alloc;
alloc.with_double = f_some_double_function_bbob_problem_allocate;

coco_noisy_problem_t *prob = coco_problem_allocate_bbob_wrap_generic(
    alloc,
    ALLOCATOR_TYPE_WITH_DOUBLE,
    2, 10, 1, 42,
    &conditioning, // 传递double参数地址
    "id_template", "name_template");

• 调用带size_t参数的函数

size_t n_peaks = 5;
coco_problem_bbob_allocator_union_t alloc;
alloc.with_size_t = f_some_size_t_function_bbob_problem_allocate;

coco_noisy_problem_t *prob = coco_problem_allocate_bbob_wrap_generic(
    alloc,
    ALLOCATOR_TYPE_WITH_SIZE_T,
    3, 10, 1, 42,
    &n_peaks, // 传递size_t参数地址
    "id_template", "name_template");

注意事项 #

• 类型安全：必须保证传入的allocator_type_t和extra_param类型匹配，否则会触发未定义行为。
• 错误处理：包装器中要处理无效类型、空指针等异常情况，避免程序崩溃。
• void*转换：使用void*传递通用参数时，转换要严格对应参数类型，不可随意强制转换。

内容的提问来源于stack exchange，提问作者Lorenzo Consoli