c - 调用具有不同数量和类型参数的函数的机制？

Question

我有一组要调用的函数例如:

void void_func();                   /* id = 0 */
void void_func1(int);               /* id = 1 */
void void_func2(int, char *);       /* id = 2 */
void void_func3(short int);         /* id = 3 */

int int_func();                     /* id = 4 */            
int int_func1(int);                 /* id = 5 */
int int_func2(float);               /* id = 6 */
int int_func3(int, int *);          /* id = 7 */

char *char_func();                  /* id = 8 */
char *char_func1(int);              /* id = 9 */
char *char_func2(int, int);         /* id = 10*/

void enum_func(enum_t);             /* id = 11*/
enum_t enum_func1(int *, int);      /* id = 12*/
enum_t enum_func2();                /* id = 13*/

我定义了以下函数指针和参数来调用上述任何函数:

typedef void * (*funcptr)();
typedef void * (*funcptr1)(void *);
typedef void * (*funcptr2)(void *, void *);

void * parameter1;
void * parameter2;
void * return_param;

我定义了一个自定义结构来调用所有函数:

typedef struct funcid {
    int id;
    funcptr f0;
    funcptr1 f1;
    funcptr2 f2;
    void * param1;
    void * param2;
    void * ret_param;
} func_id;

我已经根据 id 初始化了如下结构(任何时候都只调用上述函数之一):

func_id func_str[] = {
/*  { id,       f0      ,       f1      ,       f2      ,           param1          ,       param2          ,           ret_param       } ,*/
    { 0 , &void_func    ,   NULL        ,   NULL        , (void *)parameter1        , (void *)parameter2    , (void *)return_param      } ,
    { 1 ,   NULL        , &void_func1   ,   NULL        , (int  *)parameter1        , (void *)parameter2    , (void *)return_param      } ,
    { 2 ,   NULL        ,   NULL        , &void_func2   , (int  *)parameter1        , (char *)parameter2    , (void *)return_param      } ,
    { 3 ,   NULL        , &void_func3   ,   NULL        , (short int *)parameter1   , (void *)parameter2    , (void *)return_param      } ,
    { 4 , &int_func     ,   NULL        ,   NULL        , (void *)parameter1        , (void *)parameter2    , (int  *)return_param      } ,
    { 5 ,   NULL        , &int_func1    ,   NULL        , (int  *)parameter1        , (void *)parameter2    , (int  *)return_param      } ,
    { 6 ,   NULL        , &int_func2    ,   NULL        , (float*)parameter1        , (void *)parameter2    , (int  *)return_param      } ,
    { 7 ,   NULL        ,   NULL        , &int_func3    , (int  *)parameter1        , (int  *)parameter2    , (int  *)return_param      } ,
    { 8 , &char_func    ,   NULL        ,   NULL        , (void *)parameter1        , (void *)parameter2    , (char *)return_param      } ,
    { 9 ,   NULL        , &char_func1   ,   NULL        , (int  *)parameter1        , (void *)parameter2    , (char *)return_param      } ,
    { 10,   NULL        ,   NULL        , &char_func2   , (int  *)parameter1        , (int  *)parameter2    , (char *)return_param      } ,
    { 11, &enum_func    ,   NULL        ,   NULL        , (enum_t *)parameter1      , (void *)parameter2    , (void *)return_param      } ,
    { 12,   NULL        ,   NULL        , &enum_func1   , (int  *)parameter1        , (int  *)parameter2    , (enum_t *)return_param    } ,
    { 13, &enum_func2   ,   NULL        ,   NULL        , (str1 *)parameter1        , (void *)parameter2    , (enum_t *)return_param    } 
};

现在在 switch case 语句中我尝试调用任何函数:

printf("\nEnter Number of parameters of functions : ");
scanf("%d", ptr1);

printf("\nEnter whether the function has a return value (0/1) : ");
scanf("%d", &ret);

printf("\nWhich function to execute (function id): ");
scanf("%d", &var1);

if (*ptr1 > 0)
    printf("\nEnter the Parameters : \n");

func_id current_func;

for (i=0; i<13; i++){
    if (func_str[i].id == var1) {
        current_func = func_str[i];
        break;
    }
}

switch(*ptr1) {

    case 0: {
        if (ret == 1) {
            printf("\nEntering case 0\n");
            current_func.ret_param = (*current_func.f0)();
        }
        else {
            (*current_func.f0)();
        }
        break;
        }
    /* In actual case the parameters would be read from a memory location and the address of that can be stored in parameter1 */
    case 1: {
        printf("\nEnter Parameter 1: ");
        scanf("%d", parameter1); 
        printf("\nParameter 1 = %d\n",*(int *)parameter1);
        if (ret == 1) {
            current_func.ret_param = (*current_func.f1)(current_func.param1);
        }
        else {
            (*current_func.f1)(current_func.param1);
        }
        break;
        }
    /* In actual case the parameters would be written in a memory location and the address of that can be stored in parameter1 and parameter2 */
    case 2: { 
        printf("\nEnter Parameter 1: ");
        scanf("%d", parameter1);
        printf("\nEnter Parameter 2: ");
        scanf("%d", parameter2);
        if (ret == 1) {
            current_func.ret_param = (*current_func.f2)(current_func.param1, current_func.param2);
            printf("\nReturned parameter : current_func.ret_param = %d", *(int *)current_func.ret_param);
        }
        else {
            (*current_func.f2)(current_func.param1, current_func.param2);
        }
        break;
        }
    default:
        printf("ERROR");
}

在实际情况下，参数被写入内存位置，其地址将在初始化结构中分配适当的数据类型。

但是我面临的问题是调用函数时要传递/返回的参数的数据类型。那么是否有任何机制可以实现这种设置，使人们能够根据任何数据类型的参数数量调用任何函数。

感谢这方面的帮助。

Answer 1

我可能会阅读可变参数函数 starting here 。他们会让你做你想做的事。然后我会重写所有函数，以便它们始终在 void* 中传递变量参数，并且可能始终返回值。

如果您使用变量参数方案，您可能只需要一个函数:我没有足够仔细地阅读您的代码来确定这一点。然后，您可以将 (int) id 作为第一个参数传递，以明确告诉函数要做什么以及如何做。

您的声明将如下所示(未经测试):

#include <stdarg.h>
void *
the_func ( int id, void *arg1, ... );

您的定义如下(未经测试):

#include <stdarg.h>
void *
the_func ( int id, void *arg1, ... ) {
  #define max_args 10;   
  int i = 0;
  void *args[max_args];
  va_list arglist;
  ...
  // extract incoming args
  va_start( arglist, id );
  while ( i++ < sizeof( args )-1 ) {
    args[i] = va_arg( arglist, void* );
  }
  va_end( arglist );
// now we have all arguments in args[]
    switch ( id ) {  // dispatch on id
    case ....
    }