Question

我想知道如何将任何函数传递给函数，就像在可以接受任何函数的泛型函数指针中一样，这样做的目的是创建一个析构函数系统，所以基本上存储函数和用它来调用它的参数也存储在后面的行中，

类似的东西：

Defer(SDL_DestroyWindow, Window);

我已经处理了这些参数，但是我不知道如何管理这部分的函数指针，谢谢！

编辑：我添加了更多信息......

typedef struct {
  void** args;
} IM_Defer_Resource;
/* Defer & Whatnot */

IM_Stack* IM_Defer_Stack;

void IM_Defer_Init() {
  IM_Defer_Stack = IM_Stack_Init();
}


void IM_Defer(/* What to put here? */) {

}

void IM_Defer_All() {
  while(IM_Defer_Stack->size) {
    IM_Defer_Resource* resource = IM_Stack_Pop(IM_Defer_Stack);
    if(!resource) continue;
    /* What to do */
  }
}

我没有延迟的实际功能，但我确实将每个参数复制到堆栈中并且可以成功弹出它们，我不知道如何实现调用的变量函数

EDIT2：收到一些意见后：我认为这样更可行：延迟（SDL_DestroyWindow，“SDL_Window *”，窗口）; 我正在集思广益如何做到这一点，但我会感激一些意见

EDIT3：

/* Defer & Whatnot */
typedef struct {
  char** types;
  void** args;
  int count;
} IM_Defer_Resource;


IM_Stack* IM_Defer_Stack;

void IM_Defer_Init() {
  IM_Defer_Stack = IM_Stack_Init(IM_Get_Stack_Type(IM_Defer_Resource));
}

void IM_Defer_Internal(void* var, int n, ...) {
  char* type;
  void* arg;

  va_list args;
  va_start(args, n);

  IM_Defer_Resource resource;
  int count = n / 2;
  resource->types = calloc(count, sizeof(char*));
  resource->args = calloc(count, sizeof(void*));
  resource->count = count;

  for(count > 0; n -= 1) {
    type = va_arg(args, char*);
    resource->types[count-1] = type;
    arg = va_arg(args, void*);
    resource->args[count-1] = arg;
  }

  IM_Stack_Push(IM_Defer_Stack, &resource);
}

void IM_Defer_All() {
  while(IM_Defer_Stack->size) {
    IM_Defer_Resource* resource = IM_Stack_Pop(IM_Defer_Stack);
    if(!resource) continue;
    /* I have a char* and a void* to the resource, Now what? */
    free(resource->types);
    free(resource->args);
  }
}

这就是我想出来的，但我想知道如何将这个char *转换成一个类型......

Answer 1

正如我在评论中所说，一个大问题是，当声明一个可变参数函数时，未声明的参数受default argument promotions的约束。这意味着您可以找到与函数预期不同的传递参数，这最终会导致异常。你想做的是可行的，但非常复杂。

一个解决方案，但由于需要大量编码而受到限制，可能是：

#include <stdarg.h>
#include <stdio.h>

typedef enum { fn1, fn2, fn3, /*....*/} e_fn;

void multi_fun(e_fn fn, ...)
{
    va_list ap;
    int j;

    va_start(ap, fn); /* Requires the last fixed parameter (to get the address) */

    switch(fn)
    {
        case fn1:
        {
            //suppose prototype for fn1 to be void fn1_fn(int, float, struct  mystruct *);
            int   this_int   = va_arg(ap, int);
            float this_float = va_arg(ap, float);
            struct  mystruct *this_struct = va_arg(ap, struct  mystruct *);
            fn1_fn(this_int, this_float, this_struct);
            break;
        }

        case fn2:
        {
            ...
        }
    }
    va_end(ap);
}

Answer 2

您应该在GitHub上查看Fake Function Framework (fff)。他们使用宏来缓存模拟函数。麻省理工学院许可。但是，正如@Frankie_C所说，这需要大量的代码。定义所有宏的头文件大约是6K LOC。功能仍限于20个参数。

C：将任何函数传递给函数

2 个答案: