如何调用编译时声明未知的函数？

这确实是动态函数调用场景里的核心问题——要在运行时完全根据传入的函数签名信息，把参数正确传递给编译期未知的函数，还要正确获取返回值。下面我会拆解实现思路，再给出可运行的代码示例，帮你搞定这个函数。

要实现call_function，关键要解决三个问题：

• 如何根据函数签名把参数按正确的顺序和格式压入栈（匹配目标函数的调用约定）
• 如何安全地调用目标函数（处理不同的返回值类型）
• 调用完成后如何清理栈空间（同样依赖调用约定）

首先得明确描述函数签名的数据结构，因为你的伪代码里提到了funcdecl，我们得先把这个结构体定义清楚，才能传递参数类型和值。

先把FuncDecl和配套的类型枚举、参数结构体写出来，这样才能在运行时传递函数的返回值类型、参数数量和每个参数的类型/值：

#include <stdlib.h>
#include <stdio.h>

// 参数类型枚举，可根据需求扩展
typedef enum {
    TYPE_INT,
    TYPE_DOUBLE,
    // 可以加TYPE_FLOAT、TYPE_CHAR、TYPE_VOID_PTR等
} ArgType;

// 单个参数的信息：类型+对应的值（用union节省空间）
typedef struct {
    ArgType type;
    union {
        int intValue;
        double doubleValue;
        // 对应扩展类型的字段，比如float floatValue; void* ptrValue;
    } value;
} FuncArg;

// 完整的函数声明结构体
typedef struct {
    ArgType result_type;  // 返回值类型
    int numargs;          // 参数数量
    FuncArg* args;        // 参数列表
} FuncDecl;

这里我们基于CDECL调用约定（大部分C编译器的默认约定）来实现，它的规则是：参数从右往左压栈，调用者负责调用完成后清理栈。

注意：如果你的目标函数用的是其他调用约定（比如STDCALL），栈清理的逻辑要调整（STDCALL是函数自身清理栈）。

void call_function(void* func, const FuncDecl* funcdecl, void* result) {
    if (!func || !funcdecl || !result) {
        abort(); // 空指针检查，避免崩溃
    }

    // 1. 按调用约定压栈：从最后一个参数开始（右往左）
    for (int i = funcdecl->numargs - 1; i >= 0; --i) {
        const FuncArg* arg = &funcdecl->args[i];
        switch (arg->type) {
            case TYPE_INT:
                // x86下int是4字节，用pushl压栈；x64下用pushq，这里先适配x86
                __asm__ __volatile__ ("pushl %0" :: "r"(arg->value.intValue));
                break;
            case TYPE_DOUBLE:
                // double是8字节，x86下用pushq压栈
                __asm__ __volatile__ ("pushq %0" :: "r"(arg->value.doubleValue));
                break;
            default:
                fprintf(stderr, "Unsupported argument type\n");
                abort();
        }
    }

    // 2. 调用目标函数，根据返回值类型处理
    switch (funcdecl->result_type) {
        case TYPE_INT: {
            // 把void*转为对应返回值类型的函数指针
            int (*target_func)() = (int (*)())func;
            int res = target_func();
            *(int*)result = res;
            break;
        }
        case TYPE_DOUBLE: {
            double (*target_func)() = (double (*)())func;
            double res = target_func();
            *(double*)result = res;
            break;
        }
        default:
            fprintf(stderr, "Unsupported return type\n");
            abort();
    }

    // 3. 清理栈空间（CDECL约定：调用者负责）
    size_t total_stack_bytes = 0;
    for (int i = 0; i < funcdecl->numargs; ++i) {
        switch (funcdecl->args[i].type) {
            case TYPE_INT:
                total_stack_bytes += sizeof(int);
                break;
            case TYPE_DOUBLE:
                total_stack_bytes += sizeof(double);
                break;
            default:
                abort();
        }
    }
    // 调整栈指针，释放参数占用的栈空间
    __asm__ __volatile__ ("addl %0, %%esp" :: "r"(total_stack_bytes));
}

我们用你给出的foobar函数来测试这个实现：

// 编译时"未知"的函数（实际测试中可以是动态加载的函数，比如通过dlopen获取）
double foobar(int a, int b, int c) {
    return a * 0.1 + b * 0.2 + c * 0.3;
}

int main() {
    // 构造函数的参数列表
    FuncArg args[] = {
        {TYPE_INT, .value.intValue = 10},
        {TYPE_INT, .value.intValue = 20},
        {TYPE_INT, .value.intValue = 30}
    };
    // 构造函数声明
    FuncDecl funcdecl = {
        .result_type = TYPE_DOUBLE,
        .numargs = 3,
        .args = args
    };

    double result;
    // 调用call_function
    call_function((void*)foobar, &funcdecl, &result);

    printf("foobar(10,20,30) = %.2f\n", result); // 输出14.00
    return 0;
}

• 调用约定匹配：一定要确保call_function的实现和目标函数的调用约定一致，否则会导致栈溢出或崩溃。比如如果目标函数是STDCALL，就不需要手动清理栈（函数自身会处理）。
• 架构兼容性：上面的代码是针对x86架构写的，x64架构的栈对齐要求更严格（16字节对齐），压栈前可能需要调整栈指针，参数传递也可能用到寄存器（比如x64的fastcall约定会用RCX、RDX等寄存器传参），需要针对性调整。
• 类型安全：必须保证funcdecl的信息和目标函数的签名完全匹配，类型不匹配会直接导致程序崩溃或结果错误。
• 扩展性：如果需要支持更多类型（比如float、指针），只需要在ArgType里添加枚举，然后在压栈和返回值处理的switch里加对应的case即可。

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