如何使指针的数组调用func指针？

Question

我有代码FUNC指针数组指针数组

#include <stdio.h> 

int sum(int a, int b); 
int subtract(int a, int b); 
int mul(int a, int b); 
int div(int a, int b); 

int (*p[4]) (int x, int y); 

int main(void) 
{ 
    int result; 
    int i, j, op; 

    p[0] = sum; /* address of sum() */ 
    p[1] = subtract; /* address of subtract() */ 
    p[2] = mul; /* address of mul() */ 
    p[3] = div; /* address of div() */ 

    printf("Enter two numbers: "); 
    scanf("%d %d", &i, &j); 

    printf("0: Add, 1: Subtract, 2: Multiply, 3: Divide\n"); 
    do { 
    printf("Enter number of operation: "); 
    scanf("%d", &op); 
    } while(op<0 || op>3); 

    result = (*p[op]) (i, j); 
    printf("%d", result); 

    return 0; 
} 

int sum(int a, int b) 
{ 
    return a + b; 
} 

int subtract(int a, int b) 
{ 
    return a - b; 
} 

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

int div(int a, int b) 
{ 
    if(b) 
     return a/b; 
    else 
     return 0; 
} 

代码功能：

#include <stdio.h> 

int sum(int, int); 
int product(int, int); 
int subtract(int, int); 

int main() 
{ 
    int i = 0; 
    int a = 10; 
    int b = 5; 
    int result = 0; 
    int (*pfun[3])(int, int); 

    pfun[0] = sum; 
    pfun[1] = product; 
    pfun[2] = subtract; 

    for(i = 0 ; i < 3 ; i++) 
    { 
    result = pfun[i](a, b); 
    printf("\nresult = %d", result); 
    } 

    result = pfun[1](pfun[0](a, b), pfun[2](a, b)); 
    printf("\n\nThe product of the sum and the subtract = %d\n",result); 
} 

int sum(int x, int y) 
{ 
    return x + y; 
} 

int product(int x, int y) 
{ 
    return x * y; 
} 

int subtract(int x, int y) 
{ 
    return x - y; 
} 

现在怎么这两项目结合起来。这样指向func指针和func指针的指针数组可能有不同数量的args？任何建议。

Answer 1

您不仅需要存储具有可变数量参数的函数指针（这不是非常困难，例如可以使用union），但您还需要确保使用正确的参数调用函数，这在你的设计中有点棘手。

我建议改用stack。您的所有功能将只需要堆栈作为参数：

void sum(stack_t *stack); 
void subtract(stack_t *stack); 
void product(stack_t *stack); 

而且你的阵列可以这样声明：

typedef void callback_t(stack_t *); 

callback_t *p[] = 
{ 
    sum, 
    subtract, 
    product, 
    /* ... */ 
}; 

然后例如sum将被实现为这样：

void sum(stack_t *stack) 
{ 
    if (depth(stack) < 2) 
     perror("Not enough arguments in stack!"); 
    int b = popstack(stack); 
    int a = popstack(stack); 
    int c = a + b; 
    pushstack(stack, c); 
} 

但一元减号会以这种方式实现：

void neg(stack_t *stack) 
{ 
    if (depth(stack) < 1) 
     perror("Not enough arguments in stack!"); 
    int a = popstack(stack); 
    pushstack(stack, -a); 
} 

每个函数都决定它们需要多少个参数。来电者不需要知道。