[C] How to conditionally determine which functions are called at compile time?

Question

I'm working on implementing a very, very basic component system in C, but now I am at a point where I want to 'dynamically' call some functions. The set-up is very easy: the main program is simply an endless while loop, in which some conditions are checked and in which a "process" function is called for each enabled component.

For example, now it works like this:

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

But I want to separate it into separate components, and somehow define in a central place which parts are used. This could be done with simple defines, like so:

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

As you can see this is alright for 1 or maybe only a few components, but if I want to do this for all of these (input, network and graphics) and additional components in the future, I would have to put separate #ifdefs in there for each of them, and that's quite tedious.

In pseudo code, what I'm trying to accomplish is the following:

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

This way components could easily be added in the future. I don't really mind if the checking is done compile time or run time (although I obviously prefer compile time, but I can imagine run time is easier to implement). I have no idea how to even start.

Answer 1

What's wrong with the ol' if condition?

if (hasNetwork)
{
   network_process();
}

Answer 2

You need pointers to functions, create an array of pointers to functions and index it dynamically.

Here link about function pointers.

Answer 3

You can do this with an array of function pointers.Generally I try to avoid function pointers like the plague, but it may be your best bet.

Alternatively, you can create a component process function that takes an int argument, and then has a nasty switch statement... but for this to work, you need to keep adding to the component_process function.

Alternatively-alternatively, you could do this in C++, create a virtual Component class, that just has one method "process", with a bunch of subclasses, and you run through an array of components (actually objects of the subclasses) and call the process method.

Answer 4

your components should be an array of pointers to functions

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 5

Compile-time solution: a pre-build step and include directive inside that loop, e.g.

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

A basic script to generate that file might look like (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

Any decent build system will allow you to do that.

Answer 6

Here's an example of the syntax to do this at runtime with an array of function pointers:

void f( void ) { puts( "f" ); }
void g( void ) { puts( "g" ); }
void h( void ) { puts( "h" ); }
void (*array[])(void) = { f, h, 0 };
int main(void) {
    void (**t)(void);
    for( t = array; *t; t++ )
     (*t)();
}

Answer 7

At compile time with an X macro :

component.x is a file containing :

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

Use it with :

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

And in another place for instance :

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

and with this you can place the HAS_ defines in a single place in 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 8

Another possibility: Keep the loop as is, ie

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

and add the following preprocessor directives to the file header:

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

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

Answer 9

Function pointers are great!

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

The NELEMS macro, which I learned from Dave Hanson, is also one of my favorites.

---

P.S. Avoid #ifdef at all costs :-)