0

下面程序中的蹦床功能正常工作。我认为下面的程序会导致堆栈溢出，因为函数 thunk_f 和 thunk1 无限期地相互调用，从而导致创建新的堆栈帧。但是，我想编写一个行为更类似于非终止循环的程序，因为蹦床应该防止堆栈溢出。

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

void trampoline(void *(*func)()) {
  while (func) {
    void *call = func();
    func = (void *(*)())call;
  }
}

void *thunk1(int *param);
void *thunk_f(int *param);

void *thunk1(int *param)
{
  ++*param;
  trampoline(thunk_f(param));
  return NULL;
}

void *thunk_f(int *param) 
{
  return thunk1(param);
}

int main(int argc, char **argv)
{
  int a = 4;
  trampoline(thunk1(&a));
  printf("%d\n", a);
}
4

1 回答 1

3

您错误地使用了蹦床：不是让它调用您的函数thunk_f，而是使用函数的结果thunk_f调用它。

结果，您会遇到堆栈溢出。您可以通过返回 thunk_f而不是调用它来避免堆栈溢出（但不是无限循环） ：

void *thunk1(int *param)
{
  ++*param;
  return thunk_f;
}

trampoline并正确调用main：

int main(int argc, char **argv)
{
  int a = 4;
  trampoline(thunk1, &a);
  printf("%d\n", a);
}

当然，这需要trampoline获取一个额外的参数，以传递&a参数：

void trampoline(void *(*func)(int *), int *arg) {
  while (func) {
    void *call = func(arg);
    func = (void *(*)())call;
  }
}

这行得通——但如前所述，它只是一个没有输出的无限循环。要查看发生了什么，请放入printf内部thunk1：

void *thunk1(int *param)
{
  printf("%d\n", ++*param);
  return thunk_f;
}

最后，我可能应该注意到这是无效的 C，因为在对象指针和函数指针之间进行转换是非法的（总是在编译时带有迂腐警告！）。为了使代码合法，将函数指针包装到一个对象中：

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

struct f {
    struct f (*p)(void *);
};

void trampoline(struct f f, void *args) {
    while (f.p) {
        f = (f.p)(args);
    }
}

struct f thunk1(void *param);
struct f thunk_f(void *param);

struct f thunk1(void *param) {
    printf("%d\n", ++*((int *) param));
    return (struct f) {thunk_f};
}

struct f thunk_f(void *param) {
    return thunk1(param);
}

int main() {
    int a = 4;
    trampoline((struct f) {thunk1}, &a);
}
于 2020-04-15T14:13:02.083 回答