Блог

у меня есть код для массива указателя функции

 #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 resu<
  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", amp;i, amp;j);

  printf("0: Add, 1: Subtract, 2: Multiply, 3: Dividen");
  do {
    printf("Enter number of operation: ");
    scanf("%d", amp;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("nnThe product of the sum and the subtract = %dn",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;
}
  

теперь как объединить эти две программы. такой, что массив указателей, указывающих на указатели функции, и указатели функции могут иметь разное количество аргументов? есть предложения.

Вам не только нужно хранить указатели на функции с переменным числом аргументов (это не очень сложно, например, вы могли бы использовать union ), но вам также нужно убедиться, что вы вызываете функции с правильным аргументом, а это немного сложнее, учитывая ваш дизайн.

Я предлагаю вместо этого использовать стек. Все ваши функции будут принимать стек только в качестве аргумента:

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

Каждая функция сама решает, сколько аргументов ей нужно. Вызывающему не нужно знать.