如何有条件地确定在编译时调用了哪些函数？

Question

我正致力于在 C 中实现一个非常、非常 的基本组件系统，但现在我想“动态”调用一些函数.设置非常简单：主程序只是一个无限的 while 循环，其中检查一些条件并为每个启用的组件调用一个“进程”函数。

例如，现在它是这样工作的：

while (1) {
  input_process();
  network_process();
  graphics_process();
}

但我想将它分成单独的组件，并以某种方式在中心位置定义使用哪些部分。这可以通过简单的定义来完成，如下所示：

#define HAS_NETWORK
...
while (1) {
  input_process();
#ifdef HAS_NETWORK
  network_process();
#endif
  graphics_process();
}

正如您所看到的，这对于 1 个或可能只有几个组件是可以的，但如果我想在未来对所有这些（输入、网络和图形）和其他组件执行此操作，我将不得不单独放置#ifdefs 每个都在里面，这很乏味。

在伪代码中，我想要完成的是：

components = {'input', 'network', 'graphics'}
...
foreach component in components
  execute component_process()

这样以后可以很容易地添加组件。 我真的不介意检查是在编译时还是运行时完成（虽然我显然更喜欢编译时，但我可以想象运行时更容易实现）。我什至不知道如何开始。

Answer 1

您需要指向函数的指针，创建指向函数的指针数组并动态索引它。

这里link关于函数指针。

Answer 2

编译时解决方案：预构建步骤并在该循环内包含指令，例如

while (1) {
#include "components.generated.c"
}

生成该文件的基本脚本可能类似于 (Python)：

components = ('input', 'networking', 'graphics')
# this could also be e.g. a glob on a directory or a config file

with open('components.generated.c', 'w') as fp:
    for component in components:
        print >>fp, '%s_process();' % component

任何体面的构建系统都可以让你做到这一点。

Answer 3

ol' if 条件有什么问题？

if (hasNetwork)
{
   network_process();
}

Answer 4

函数指针很棒！

typedef void (*process_fun)(void);

process_fun processes[] = 
         { input_process, network_process, graphics_process };

#define NELEMS(A) (sizeof(A) / sizeof((A)[0]))

while (1) {
  for (int i = 0; i < NELEMS(processes); i++)
    processes[i]();
}

NELEMS 宏是我从 Dave Hanson 那里学来的，也是我的最爱之一。

---

附：不惜一切代价避免#ifdef :-)

Answer 5

在编译时使用 X 宏：

component.x 是一个包含 :

的文件

COMPONENT( graphic , "3D graphics rendering" )
COMPONENT( network , "Network" )
COMPONENT( other , "usefull stuff" )
#undef COMPONENT

使用它：

#define COMPONENT( what , description ) what ## _process();
while (1)
{
#include "components.x"
}

例如在另一个地方：

std::cout << "We use :\n" ;
#define COMPONENT( what , description )\
std::cout << #what << " : " << description << "\n" ;
#include "components.x"

这样您就可以将 HAS_ 定义放在 component.x 中的一个位置：

#ifdef HAS_GRAPHIC
COMPONENT( graphic , "3D graphics rendering" )
#endif
#ifdef HAS_NETWORK
COMPONENT( network , "Network" )
#endif
#ifdef HAS_OTHER
COMPONENT( other , "usefull stuff" )
#endif
#undef COMPONENT

Answer 6

你可以用函数指针数组来做到这一点。一般我尽量避免像瘟疫一样的函数指针，但这可能是你最好的选择。

或者，您可以创建一个采用 int 参数的组件流程函数，然后使用令人讨厌的 switch 语句...但是要使其正常工作，您需要不断添加到 component_process 函数。

或者，您可以在 C++ 中执行此操作，创建一个虚拟组件类，它只有一个方法“进程”，带有一堆子类，然后您运行一组组件（实际上是子类的对象）并调用 process 方法。

Answer 7

你的组件应该是一个指向函数的指针数组

enum components
{
    input,
    network,
    graphics,
    num_components
}

void process_audio()
{
}

void process_network()
{
}

void process_graphics()
{
}

void (*process_component[num_components])();

process_component[0] = &process_audio;
process_component[1] = &process_network
process_component[2] = &process_graphics;

for (int i = 0; i < num_components; i++)
    process_component[i]();

Answer 8

以下是在运行时使用函数指针数组执行此操作的语法示例：

无效f（无效）{put（“f”）； } 无效g（无效）{put（“g”）； } 无效h（无效）{put（“h”）； } void (*array[])(void) = { f, h, 0 }; 诠释主要（无效）{ 无效（**t）（无效）； for( t = 数组; *t; t++ ) (*t)(); }

Answer 9

另一种可能性：保持循环不变，即

while (1) {
  input_process();
  network_process();
  graphics_process();
}

并将以下预处理器指令添加到文件头：

#ifndef HAS_NETWORK
#define network_process() ((void)0)
#endif

#ifndef HAS_GRAPHICS
#define graphics_process() ((void)0)
#endif