函数作为C中的函数参数

我想创建一个单独的函数，因为我多次使用

if

语句中的代码。但是这个函数必须有一个函数作为参数，因为我使用递归方法。我知道我们可以使用函数作为参数，但是在

f

函数中有3个参数，在

g

函数中有4个参数

f

中if语句中的代码与

g

中if语句中的代码相同。除了代码中的函数调用

---

只是我不知道如何解决这个问题。

我不知道你到底想做什么。但如果您担心if语句中的代码重复，可以将其重构为另一个函数：

void f(int a, char b, char* c) {
    if(..) {
        ...
        f(a,b,c); //recursive
    }
    ...
}
void g(int a, double b, char* c, int d) {
    if(..) {
        ...
        g(a,b,c,d); //recursive
    }
    ...
}

---

我建议您使用一种简单的修复方法，但它通常不起作用，因为它涉及到哨兵值的使用

假设传递给

g

的变量

d

始终为正。然后您可以选择

-1

作为哨兵值

您总是将四个参数传递给函数

myIf

，然后检查

d

是否为

-1

。如果是，则使用三个参数调用

f

，否则调用

g

if (isCondition()) ...

bool isCondition() { return ... }

---

您可以使用union来打包可变数量的参数，如下面的示例代码所示。 像这样使用union可能是不寻常的，但它是有效的

int main() {

    myIf(a, b, c, d);

    return 0;
}

void myIf(int a, int b, char *c, int d)
{
    if( d == -1 ) {
        
        f(a, b, c);
    }
    else {
        
        g(a, b, c, d);
    }
}

#包括
联合大学{
结构{inta；char b；char*c；}f；
结构{inta；双b；字符*c；intd；}g；
};
无效函数（联合单位）{
printf（“f={a:%d，b:%c，c:%s}\n”，ua->f.a，ua->f.b，ua->f.c）；
ua->f.a++；
}
无效职能（工会联合会）{
printf（“g={a:%d，b:%e，c:%s，d:%d}\n”，
ua->g.a，ua->g.b，ua->g.c，ua->g.d）；
ua->g.a++；ua->g.b*=2.0；ua->g.d++；
}
无效r（内部i，无效（*func）（联合u*），联合u*ua）{
如果（i<3）{/*或任何终止递归的条件*/
printf（“递归%d\n”，i）；
func（ua）；
r（++i，func，ua）；
}否则{
printf（“在%d\n处退出递归”，i）；
返回；
}
}
int main（）{
工会u1、u2；
/*f*/
u1.f.a=10；u1.f.b='X'；u1.f.c=“我是u.f.”；
r（0，&func\u\f，&u1）；
/*g*/
u2.g.a=10；u2.g.b=0.4e-6；u2.g.c=“我是u.g.”u2.g.d=98；
r（-2，&func\u\g，&u2）；
返回0；
}

你是说

f

中的

if

语句中的代码与

g

中的

if

语句中的代码相同吗？除了那段代码中的函数调用？@kol是的，一切都是相同的，你需要用四个或三个参数与编译器通信。你可以创建两个函数：一个包含函数调用前的代码部分，您还可以创建一个参数数量可变的宏，其中要调用的函数（

f

或

g

）及其参数（

a、b、c

或

a、b、c、d

）位于宏的最后，在

if

语句的代码要求的其他参数之后。不只是条件是一样的。OP希望传入要作为参数调用的函数。这是如何编译的？或者它是作为伪代码？是的，它不编译。这只是为了让概念形象化。

#include<stdio.h>

union u {
  struct { int a; char   b; char* c;        } f;
  struct { int a; double b; char* c; int d; } g;
};

void func_u_f (union u* ua) {
  printf("  f = {a: %d, b: %c, c:%s}\n", ua->f.a, ua->f.b, ua->f.c);
  ua->f.a++;
}

void func_u_g (union u* ua) {
  printf("  g = {a: %d, b: %e, c:%s, d:%d}\n",
         ua->g.a, ua->g.b, ua->g.c, ua->g.d);
  ua->g.a++; ua->g.b *= 2.0; ua->g.d++;
}

void r (int i, void (*func) (union u*), union u* ua) {
  if (i < 3) { /* or whatever conditions to terminate recursion */
    printf ("Recursion %d\n", i);
    func(ua);
    r (++i, func, ua);
  } else {
    printf ("Exit recursion at %d\n", i);
    return;
  }
}

int main () {
  union u u1, u2;

  /* f */
  u1.f.a = 10; u1.f.b = 'X'; u1.f.c = "I am u.f.";
  r(0, &func_u_f, &u1);
  /* g */
  u2.g.a = 10; u2.g.b = .4e-6; u2.g.c = "I am u.g."; u2.g.d = 98;
  r(-2, &func_u_g, &u2);

  return 0;
}