如何创建一个返回函数的函数？

Question

大图：我有一个带有函数的模块和一个带有这些函数的过程和函数的模块。

当我结合两个函数时（来自函数的模块接口）：

double f1(double alpha, double x);
double f2(double beta, double x);

在几个方面，（其中之一是添加）：

double OP_Addition(double (*f)(double,double) , double (*g)(double,double), double param1, double param2, double x);

对以下（部分）实现没有任何问题：

z1 = (*f)(param1, x);
z2 = (*g)(param2, x);
y = z1 + z2;
return y;

但是当我想返回一个指向“新”函数的指针时，类似于：

void *OP_PAdd( double (*f)(double,double), double param3 );

我不能让它正常工作，也不能做出正确的“调用”。我想在其他函数中使用输出“函数”作为输入。

Answer 1

当从另一个函数返回一个函数时，最简洁的方法是使用typedef：

typedef double (*ftype)(double, double);

然后你可以像这样声明你的函数：

ftype OP_PAdd( ftype f, double param3 )
{
    ....
    return f1;
}

你可以在没有typedef 的情况下做到这一点，但它很乱：

double (*OP_PAdd( double (*f)(double,double), double param3 ))(double,double)
{
    return f1;
}

因此，当您将函数指针作为参数或其他函数的返回值时，请使用typedef。

编辑：

虽然你可以像这样声明类型：

typedef double ftype(double, double);

在实践中你永远不能直接使用这样的类型。一个函数不能返回一个函数（只有一个指向函数的指针），并且这个类型的变量不能被赋值。

此外，您不需要显式取消引用函数指针来调用函数，因此隐藏指针本身并不是一个大问题。将函数指针定义为typedef 也是惯例。来自man page for signal：

   #include <signal.h>

   typedef void (*sighandler_t)(int);

   sighandler_t signal(int signum, sighandler_t handler);

Answer 2

其他答案是正确且有趣的，但您应该知道，在便携式 C99 中，没有办法将真正的 closures 作为 C 函数（这是一个基础 C) 的限制。如果你不知道闭包是什么，请仔细阅读 the wiki 页面（同时阅读 SICP，尤其是 §1.3）。但是请注意，在C++11 中确实有闭包，使用std::function 和lambda-expressions。大多数其他编程语言（Ocaml、Haskell、Javascript、Lisp、Clojure、Python 等）都有闭包。

由于 C 语言中缺乏真正的闭包（“数学上”，C 函数中唯一的闭包值是全局变量或静态变量或文字），大多数接受 C 函数指针的库都提供了一个 API 处理 callbacks 和一些客户端数据（一个简单的例子可能是qsort_r，但更认真地看看内部GTK)。该客户端数据（通常是不透明的指针）可用于保持封闭值。您可能希望遵循类似的约定（因此系统地将函数指针作为带有一些附加客户端数据的回调传递），因此您需要更改 C 函数的签名（而不是仅传递原始函数指针，您将传递函数指针和一些客户端数据作为回调，以“模拟”闭包）。

您有时可以在运行时生成 C 函数（使用非标准功能，可能在操作系统或某些外部库的帮助下）。您可能会使用一些 JIT compiling 库，例如 GNU lightning、libjit（两者都会快速生成一些运行缓慢的代码）、asmjit（您将显式生成每条机器指令，快速发出是您的责任x86-64 代码）、GCCJIT 或 LLVM（两者都在现有编译器之上，因此可用于发出 - 有点慢 - 一些优化的代码）。在 POSIX 和 Linux 系统上，您还可以在某个临时文件 /tmp/tempcode.c 中发出一些 C 代码，将该代码的编译（例如 gcc -fPIC -Wall -O2 -shared /tmp/tempcode.c -o /tmp/tempcode.so）分叉到插件中，并使用 dlopen(3) 和 @987654338 动态加载生成的插件@..

顺便说一句，我们不知道您正在编写的实际应用程序是什么，但您可以考虑在其中嵌入一些解​​释器，例如Lua 或 Guile。然后，您将使用并向嵌入式评估器/解释器提供回调。

Answer 3

你的意思是这样的吗？ decider() 函数返回一个指向另一个函数的指针，然后调用该函数。

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

typedef double(*fun)(double, double);

double add(double a, double b) {
    return a + b;
}

double sub(double a, double b) {
    return a - b;
}

double mul(double a, double b) {
    return a * b;
}

fun decider(char op) {
    switch(op) {
        case '+': return add;
        case '-': return sub;
        case '*': return mul;
    }
    exit(1);
}

int main(void)
{
    fun foo;

    foo = decider('+');
    printf("%f\n", foo(42.0, 24.0));

    foo = decider('-');
    printf("%f\n", foo(42.0, 24.0));

    foo = decider('*');
    printf("%f\n", foo(42.0, 24.0));

    return 0;
}

程序输出：

66.000000
18.000000
1008.000000

编辑：在 @dbush 答案 下的 cmets 之后，此版本从 typedef 作为指针退回到只是一个函数。它给出了相同的输出，但在decider() 中它编译干净并给出正确的输出，无论我写的是return add; 还是return &add;

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

typedef double(fun)(double, double);

double add(double a, double b) {
    return a + b;
}

double sub(double a, double b) {
    return a - b;
}

double mul(double a, double b) {
    return a * b;
}

fun *decider(char op) {
    switch(op) {
        case '+': return add;     // return &add;
        case '-': return sub;
        case '*': return mul;
    }
    exit(1);
}

int main(void)
{
    fun *foo;

    foo = decider('+');
    printf("%f\n", foo(42.0, 24.0));

    foo = decider('-');
    printf("%f\n", foo(42.0, 24.0));

    foo = decider('*');
    printf("%f\n", foo(42.0, 24.0));

    return 0;
}

Answer 4

在C中，你可以返回指向函数的指针，但要做到这一点，函数需要首先存在，动态创建函数并不是C说的可以的，别管怎么做

如果您的代码只能在一个操作系统和一个处理器上运行（可能还有其他一些限制），您可以：

1. 分配内存页
2. 写数据和机器代码做你想做的事，调用指针传递的函数等等。
3. 将内存保护从读/写更改为读/执行
4. 返回指向创建函数的指针
5. 不用担心每个函数需要 4kB

可能有一些库可以做到这一点，但不一定是可移植的

Answer 5

所以你想要一个函数返回一个指向函数的指针。

double retfunc()
{
   return 0.5;
}

double (*fucnt)()
{
  return retfunc;
}

main()
{
   printf("%f\n", (*funct())());
}

Answer 6

由于有些人显然对编写 hack 来解决这个问题感到偏执，这里有一个不那么 hack 的方法：使用带有 setjmp 和 longjmp 的静态结构。

jmp_buf jb;

void *myfunc(void) {
    static struct {
        // put all of your local variables here.
        void *new_data, *data;
        int i;
    } *_;
    _ = malloc(sizeof(*_));
    _.data = _;
    if (!(_.new_data = (void *)(intptr_t)setjmp(jb)))
        return _.data;
    _.data = _.new_data;
    /* put your code here */
    free(_);
    return NULL;
}

为了解释这里发生了什么，setjmp 将在创建跳转缓冲区时返回值 0，否则它将返回 longjmp 传递的值（例如 longjmp(jb, 5) 将导致 setjmp 返回 5） .

所以，我们正在做的是让我们的函数返回一个指向它分配的数据结构的指针；然后像这样调用我们的闭包：

void *data = myfunc();
longjmp(jb, (int)(intptr_t)data);

请注意，不能保证 int 大到足以在所有平台上存储指针；因此您可能需要创建一个数据池并通过句柄（池中的索引）返回/传递数据。

正如我之前所说，闭包只是一个函数，它的所有数据都分配在堆上。

多年来，我一直在为 N64 和 PSP 游戏编写 hack。声称这是不可能的人可能从未修补过这种东西。主要归结为缺乏经验。

Answer 7

我会在这里变得很老套，所以抓住你的马裤。

标准 C api 带有两个函数，称为 setjmp 和 longjmp。除了糟糕的命名之外，它们本质上所做的是将当前状态（包括堆栈位置和寄存器值）的副本存储到 jmp_buf（或者，技术名称，continuation）中。

现在，假设您创建了一个函数：

jmp_buf jb;

void sfunc(void) {
    void *sp_minus1 = 0xBEEFBABE;
    setjmp(jb);
}

当你调用 sfunc 时，会创建一个栈帧。因为这个函数没有参数，堆栈中的第一个条目将是返回地址，紧随其后的是 sp_minus1 对象。

为什么这是相关的？嗯，sp_minus1 的地址是相对于堆栈帧的开始的。如果你能在jb找到栈帧的地址，你可以把它改成……比如说，堆中的某个位置？

我们现在得到的是一种为堆上的 longjmp 函数调用创建堆栈帧的方法，该堆栈帧可以包含有关调用它们的上下文的附加状态；或者换句话说，闭包。

我认为我从未见过有人以这种方式使用 longjmp/setjmp，但如果您正在寻找一种在 C 中动态生成和返回函数的方法，我认为这将是您的最佳途径。

编辑：

这是我所描述的 hack 的示例实现：

#include <inttypes.h>  // intptr_t
#include <setjmp.h>    // longjmp, setjmp
#include <stdio.h>     // printf
#include <stdlib.h>    // malloc, free
#include <string.h>    // memcpy


typedef struct {
    jmp_buf jb;
    int fixupc;
    int fixupv[10];
    size_t stack_size;  // this is only an approximation
    void *stack_ptr;
} CLOSURE;


int getclosure(CLOSURE *closure) {
    unsigned int i, size;
    void *i_ptr = &i, *sp;
    unsigned char *data = (unsigned char *)(void *)closure->jb;
    memset(closure, 0, sizeof(CLOSURE));
    if (!setjmp(closure->jb)) {
        printf("looking for 0x%08X...\n\n", (unsigned int)(intptr_t)i_ptr);
        for (i = 0; i < sizeof(closure->jb); i++) {
            memcpy(&sp, &data[i], sizeof(void *));
            size = (unsigned int)(intptr_t)(sp - i_ptr);
            if (size < 0x300) {
                closure->fixupv[closure->fixupc++] = i;
                printf("  fixup @ 0x%08X\n", (unsigned int)(intptr_t)sp);
                if (sp > closure->stack_ptr) {
                    closure->stack_size = size;
                    closure->stack_ptr = sp;
                }
            }
        }
        if (!closure->stack_ptr)
            return 0;
        printf("\nsp @ 0x%08X\n", (unsigned int)(intptr_t)closure->stack_ptr);
        printf("# of fixups = %i\n", closure->fixupc);
        /*
         * once we allocate the new stack on the heap, we'll need to fixup
         * any additional stack references and memcpy the current stack.
         *
         * for the sake of this example, I'm only fixing up the pointer
         * to the stack itself.
         *
         * after that, we would have successfully created a closure...
         */
         closure->stack_size = 1024;
         sp = malloc(closure->stack_size);
         memcpy(sp, closure->stack_ptr, closure->stack_size);
         memcpy(&data[closure->fixupv[0]], &sp, sizeof(void *));
         closure->stack_ptr = sp;
         return 1;
    } else {
        /*
         * to this bit of code right here
         */
        printf("holy shit!\n");
        return 0;
    };
}

void newfunc(CLOSURE *closure) {
    longjmp(closure->jb, 1);
}

void superfunc(CLOSURE *closure) {
    newfunc(closure);
}

int main(int argc, char *argv[]) {
    CLOSURE c;
    if (getclosure(&c)) {
        printf("\nsuccess!\n");
        superfunc(&c);
        free(c.stack_ptr);
        return 0;
    }
    return 0;
}

这在技术上是一种堆栈粉碎形式，因此默认情况下，GCC 会生成堆栈金丝雀，从而导致程序中止。如果你用'-fno-stack-protection'编译，它会起作用。