用不同数量和类型的参数调用函数的机制？

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 } 
}; 

现在，在一个开关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"); 
} 

在实际情况下，参数写入直到在初始化结构中其地址将被赋予适当的数据类型的存储器位置。

但是我面临的问题是在调用函数时要传递/返回的参数的数据类型为w.r.t。那么是否有这种设置的机制，可以根据任何数据类型的参数数量来调用任何函数。

欣赏这方面的帮助。

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 .... 
    }