一个有趣的问题，我查看了引用的答案中的论文 (More functional reusability in C/C++/Objective-C with Curried functions)。
因此，以下是您可能想去的建议路径。我不认为这真的是一个 Curried 函数，因为我不完全理解论文在说什么，而不是一个函数式程序员。然而，做一些工作，我发现这个概念的一些有趣的应用。另一方面，我不确定这是否是您想要的，您可以在 C 中做到这一点让我大吃一惊。
似乎有两个问题。
首先是能够处理带有任意参数列表的任意函数调用。我采用的方法是使用标准 C 库变量参数功能（带有 va_start()、va_arg() 和 va_end() 函数的 va_list），然后将函数指针与提供的参数一起存储到数据区域中，以便它们然后可以在以后执行。我借用并修改了printf() 函数如何使用格式行来了解提供了多少个参数及其类型。
接下来是函数及其参数列表的存储。我只是使用了一个任意大小的结构来尝试这个概念。这需要更多的思考。
这个特定版本使用一个被视为堆栈的数组。有一个函数可以用来将一些任意函数及其参数推送到堆栈数组中，还有一个函数可以将最顶层的函数及其参数从堆栈数组中弹出并执行。
但是，您实际上可以在某种集合中包含任意结构对象，例如哈希映射，这可能非常酷。
我只是借用了论文中的信号处理程序示例来表明该概念适用于那种应用程序。
所以这里是源代码，我希望它可以帮助你想出一个解决方案。
您需要向开关添加其他情况，以便能够处理其他参数类型。我只是做了一些概念证明。
虽然这似乎是一个相当简单的扩展，但它也不会调用函数。就像我说的，我不完全理解这个 Curried 的东西。
#include <stdarg.h>
#include <string.h>
// a struct which describes the function and its argument list.
typedef struct {
void (*f1)(...);
// we have to have a struct here because when we call the function,
// we will just pass the struct so that the argument list gets pushed
// on the stack.
struct {
unsigned char myArgListArray[48]; // area for the argument list. this is just an arbitray size.
} myArgList;
} AnArgListEntry;
// these are used for simulating a stack. when functions are processed
// we will just push them onto the stack and later on we will pop them
// off so as to run them.
static unsigned int myFunctionStackIndex = 0;
static AnArgListEntry myFunctionStack[1000];
// this function pushes a function and its arguments onto the stack.
void pushFunction (void (*f1)(...), char *pcDescrip, ...)
{
char *pStart = pcDescrip;
AnArgListEntry MyArgList;
unsigned char *pmyArgList;
va_list argp;
int i;
char c;
char *s;
void *p;
va_start(argp, pcDescrip);
pmyArgList = (unsigned char *)&MyArgList.myArgList;
MyArgList.f1 = f1;
for ( ; *pStart; pStart++) {
switch (*pStart) {
case 'i':
// integer argument
i = va_arg(argp, int);
memcpy (pmyArgList, &i, sizeof(int));
pmyArgList += sizeof(int);
break;
case 'c':
// character argument
c = va_arg(argp, char);
memcpy (pmyArgList, &c, sizeof(char));
pmyArgList += sizeof(char);
break;
case 's':
// string argument
s = va_arg(argp, char *);
memcpy (pmyArgList, &s, sizeof(char *));
pmyArgList += sizeof(char *);
break;
case 'p':
// void pointer (any arbitray pointer) argument
p = va_arg(argp, void *);
memcpy (pmyArgList, &p, sizeof(void *));
pmyArgList += sizeof(void *);
break;
default:
break;
}
}
va_end(argp);
myFunctionStack[myFunctionStackIndex] = MyArgList;
myFunctionStackIndex++;
}
// this function will pop the function and its argument list off the top
// of the stack and execute it.
void doFuncAndPop () {
if (myFunctionStackIndex > 0) {
myFunctionStackIndex--;
myFunctionStack[myFunctionStackIndex].f1 (myFunctionStack[myFunctionStackIndex].myArgList);
}
}
// the following are just a couple of arbitray test functions.
// these can be used to test that the functionality works.
void myFunc (int i, char * p)
{
printf (" i = %d, char = %s\n", i, p);
}
void otherFunc (int i, char * p, char *p2)
{
printf (" i = %d, char = %s, char =%s\n", i, p, p2);
}
void mySignal (int sig, void (*f)(void))
{
f();
}
int main(int argc, char * argv[])
{
int i = 3;
char *p = "string";
char *p2 = "string 2";
// push two different functions on to our stack to save them
// for execution later.
pushFunction ((void (*)(...))myFunc, "is", i, p);
pushFunction ((void (*)(...))otherFunc, "iss", i, p, p2);
// pop the function that is on the top of the stack and execute it.
doFuncAndPop();
// call a function that wants a function so that it will execute
// the current function with its argument lists that is on top of the stack.
mySignal (1, doFuncAndPop);
return 0;
}
您还可以从中获得一点乐趣，即在由doFuncAndPop() 调用的函数中使用pushFunction() 函数，以使您可以将另一个函数及其参数放入堆栈。
例如，如果您将上面源代码中的函数 otherFunc() 修改为如下所示：
void otherFunc (int i, char * p, char *p2)
{
printf (" i = %d, char = %s, char =%s\n", i, p, p2);
pushFunction ((void (*)(...))myFunc, "is", i+2, p);
}
如果您随后添加另一个对doFuncAndPop() 的调用，您将看到首先执行otherFunc()，然后执行在otherFunc() 中的对myFunc() 的调用，最后是被推送的myFunc() 调用在main () 中被调用。
编辑 2：
如果我们添加以下函数，这将执行所有已放入堆栈的函数。这将允许我们通过将函数和参数压入堆栈然后执行一系列函数调用来创建一个小程序。这个函数还允许我们推送一个没有任何参数的函数，然后推送一些参数。当从堆栈中弹出函数时，如果参数块没有有效的函数指针，那么我们所做的就是将该参数列表放到堆栈顶部的参数块上，然后执行它。也可以对上面的函数doFuncAndPop() 进行类似的更改。如果我们在一个执行的函数中使用 pushFunction() 操作，我们可以做一些有趣的事情。
实际上这可能是Threaded Interpreter 的基础。
// execute all of the functions that have been pushed onto the stack.
void executeFuncStack () {
if (myFunctionStackIndex > 0) {
myFunctionStackIndex--;
// if this item on the stack has a function pointer then execute it
if (myFunctionStack[myFunctionStackIndex].f1) {
myFunctionStack[myFunctionStackIndex].f1 (myFunctionStack[myFunctionStackIndex].myArgList);
} else if (myFunctionStackIndex > 0) {
// if there is not a function pointer then assume that this is an argument list
// for a function that has been pushed on the stack so lets execute the previous
// pushed function with this argument list.
int myPrevIndex = myFunctionStackIndex - 1;
myFunctionStack[myPrevIndex].myArgList = myFunctionStack[myFunctionStackIndex].myArgList;
}
executeFuncStack();
}
}
编辑 3：
然后我们对pushFunc() 进行更改以使用以下附加开关处理双精度：
case 'd':
{
double d;
// double argument
d = va_arg(argp, double);
memcpy (pmyArgList, &d, sizeof(double));
pmyArgList += sizeof(double);
}
break;
因此，使用这个新功能，我们可以执行以下操作。首先创建类似于原始问题的两个函数。我们将在一个函数中使用 pushFunction() 来推送参数，然后由堆栈上的下一个函数使用。
double f1 (double myDouble)
{
printf ("f1 myDouble = %f\n", myDouble);
return 0.0;
}
double g2 (double myDouble) {
printf ("g2 myDouble = %f\n", myDouble);
myDouble += 10.0;
pushFunction (0, "d", myDouble);
return myDouble;
}
我们将新功能与以下一系列语句一起使用：
double xDouble = 4.5;
pushFunction ((void (*)(...))f1, 0);
pushFunction ((void (*)(...))g2, "d", xDouble);
executeFuncStack();
这些语句将首先执行值为 4.5 的函数 g2()，然后函数 g2() 会将其返回值推送到我们的堆栈中，以供函数 f1() 使用，该函数首先被推送到我们的堆栈中。