使用循环调用'；按顺序'；C语言中的命名函数

假设我有函数foo_1（），foo_2（），…foo_n（）

如何使用循环调用它们，即如何将字符串“转换”为函数调用：

for (i = 0; i < n; i++)
    switch (fork()) {
        case 0:         //child process
            *COMVAR+=m;
            //call foo_i()
            exit(4);
        case -1:
            exit(5);
   }

（i=0；i 开关（fork（））{ 案例0://子进程 *COMVAR+=m； //呼叫foo_i（） 出口（4）； 案例1： 出口（5）； }

---

具有反射的高级语言（如Java）能够执行此类操作，但C不能。在Java中，您可以执行以下操作：

您有一个名为

MyClass

public class MyClass {
    public void myMethodName(String arg1);
}

您可以使用下面的流调用

myMethodName

，使用String表单

Class myObject = new MyClass();
Class<?> c = Class.forName("MyClass");
Class[] argTypes = new Class[] { String[].class };
Method method = c.getDeclaredMethod("myMethodName", argTypes);
method.invoke(myObject, params);

Class myObject=new MyClass（）；
c类=Class.forName（“MyClass”）；
类[]argTypes=新类[]{String[].Class}；
方法Method=c.getDeclaredMethod（“myMethodName”，argTypes）；
调用（myObject，params）；

---

以下是官方文档：

您不能让编译器或运行时在C中自动执行此操作，但您可以手动列出函数指针并在循环中调用它们，即：

// create your function prototype, which all functions must use
typedef void(*VoidFunc)(void);

// create the array of pointers to actual functions
VoidFunc functions[] = { foo_1, foo_2, foo_3 };

// iterate the array and invoke them one by one
int main(void)
{
    for (int i = 0; i < sizeof(functions) / sizeof(*functions); i++)
    {
        VoidFunc fn = functions[i];
        fn();
    }

    return 0;
}

//创建所有函数都必须使用的函数原型
类型定义无效（*VoidFunc）（无效）；
//创建指向实际函数的指针数组
VoidFunc函数[]={foo_1，foo_2，foo_3}；
//迭代数组并逐个调用它们
内部主（空）
{
对于（int i=0；i

请记住，

void func（）

与C中的

void func（void）

不同。

否

最好的方法是使用一系列函数指针

#include <stdio.h>

typedef int (*fx)(void); // fx is pointer to function taking no parameters and returning int

int foo_1(void) { printf("%s\n", __func__); return 1; }
int foo_2(void) { printf("%s\n", __func__); return 2; }
int foo_three(void) { printf("%s\n", __func__); return 3; }

int main(void) {
    fx foo[3] = { foo_1, foo_2, foo_three };
    for (int k = 0; k < 3; k++) {
        printf("foo[%d]() returns %d\n", k, foo[k]());
    }
}

#包括
typedef int（*fx）（无效）；//fx是指向不带参数并返回int的函数的指针
int foo_1（void）{printf（“%s\n”），函数；返回1；}
int foo_2（void）{printf（“%s\n”），\uuuuu func\uuuuu；返回2；}
int foo_三（void）{printf（“%s\n”），函数；返回3；}
内部主（空）{
fx foo[3]={foo_1，foo_2，foo_3}；
对于（int k=0；k<3；k++）{
printf（“foo[%d]（）返回%d\n”，k，foo[k]（））；
}
}

---

通常，您的方法在C语言中是不可能的。 但是您可以通过使用语句来实现。 虽然你必须写一点代码

switch (n)
​{
    case 1:
        foo_1();
        break;

    case 2:
        foo_2();
        break;
    case 3:
        foo_3();
        break;
        .
        .
        .
    case n:
        foo_n();
        break;
    default:
        // code to be executed if n doesn't match any constant
}

---

在C.你不能这么做，你可能需要考虑一系列函数指针——然后你可以在这个数组上迭代。看看函数指针，你能告诉我们为什么要这么做吗？我相当肯定，只有定义100个函数，其中包含任意数字，它们的作用完全相同，并且可以重写为

foo（int-index）

，才能解决这个问题。。。如果您在它上面循环，那么只使用

for（inti=0；i

应该没有问题，就像函数名中的索引不仅仅是一个索引，否则您会给它命名一些有意义的东西。事实上，没有人质疑这一点，只是回答好像这是一个好主意，令人难以置信。@PurpleIce我们目前正在学习分叉。我使用一个循环来启动多个fork，这似乎是让每个fork执行不同功能的最简单方法。实际上需要for循环的fork需要多少次？另外，如果每个fork需要做不同的事情，那么它们可能定义得足够好，您可以想出一些没有

foo_i

那么神秘的名称，因为只有一个fork进程可以foo，而不是所有的fork进程？顺便说一下，如果你在一个循环中分叉，每个分叉的进程都会再次分叉，而不仅仅是在for循环中开始的主进程，我不认为这是你想要的。我认为您不需要超过5次分叉，因此我建议您在不偷懒的情况下写出它们。实际上，您最好将函数重写为

foo（int I）

，因为如果您确实选择函数中包含任意数，很明显，你只是在使用一些随机硬编码索引，这些索引可以传递到函数本身…@PurpleIce：我同意我编写的示例函数不是最好的。谢谢你的提醒！哦，我不是在评论你的答案，而是问题本身。存储这么多功能完全相同的函数是没有意义的，如果没有，它们就不会被称为

foo_i

，这个例子本身就很好。虽然有更好的方法来解决这个问题，但通常如果我们想调用5个函数，一般的方法基本上是一样的，我们创建了另一个函数来封装这5个函数。这与我想要的不完全一样，但已经足够接近了。我不知道函数指针。到目前为止，最好的方法似乎是使用一个接受arg=i的函数，并将其用于函数中的switch/if语句。您是否有一个资源链接，用于在Java中教授如何这样做？