C: how to apply a sequence of variables to a function?

Question

In C, is there a way to call a function with arguments stored in some array? I'm a C newbie, I'm not even sure if this is right but e.g.:

void f0(int a) { ... };
void f1(int a, int b) { ... };
void f2(int a, int b, int c) { ... };

int array[5][2][?] = [
    [&f0, [5]],
    [&f1, [-23, 5]],
    [&f2, [0, 1, 2]],
    [&f2, [1235, 111, 4234]],
    [&f0, [22]]
];

int i;
for (i = 0; i < 5; i++) {
    APPLY?(array[i][0], array[i][1])
}

PS: What kind of structure should I use when the array's items vary in length?

In Python, this would be:

def f0(a): ...
def f1(a, b): ...
def f2(a, b, c): ...

array = [
    (f0, (5,)),
    (f1, (-23, 5)),
    (f2, (0, 1, 2)),
    (f2, (1235, 111, 4234)),
    (f0, (22,))
]

for f, args in array:
    apply(f, args)

Answer 1

Not really, no.

A better way to do this in C would be to define your functions to all have the same signature, like:

void f0(int size, int elements[])

and then pass arrays of the appropriate size to your functions.

// this is a function pointer
void (*x)(int, int[]); 
...
// set x to point at f0
x = f0;
// call x (ie: f0) with 1 element from position 5 of array
x(1, &(array[5]));

Answer 2

There might be a simpler way to accomplish your goal, what are you trying to do? and what are your limitations with data etc?

Answer 3

It's possibly to have variable arity functions in C, but the mechanism is clunky and has certain restrictions, namely, there must be at least one fixed parameter, and you need to be able to tell from the fixed parameters or from the variable parameters themselves where the end of the variable list is.

A more typical solution, one that plays to C's strengths rather than its weaknesses, is something like this example. (Updated with function pointers.)

#include <stdio.h>

void f1(int, int *);
void f2(int, int *);

struct BoxOfInts {
    void (*f)(int,int *);
    int howMany;
    int theNumbers[4];
} intMachine[] = {
    {f1, 1,  { 5,  }},
    {f2, 2,  { -23, 5  }},
    {f1, 3,  { 0, 1, 2  }},
    {f2, 3,  { 1235, 111, 4234  }},
    {f1, 1,  { 22,  }},
    { 0 }
};

void dispatch(void)
{
    for(struct BoxOfInts *p = intMachine; p->f; ++p)
        (*p->f)(p->howMany, p->theNumbers);
}

void f1(int howMany, int *p)
{
    while (howMany-- > 0) {
        int t = *p++;
        printf("f1 %d %d\n", howMany, t);
    }
}

void f2(int howMany, int *p)
{
    while (howMany-- > 0) {
        int t = *p++;
        printf("f2 %d %d\n", howMany, t);
    }
}

int main()
{
  dispatch();
  return 0;
}

Answer 4

I think perhaps you just want:

array[i][0](array[i][1]);

To call a function from its pointer in C only requires the function call operator, which is parentheses.

Possibly useful link: http://boredzo.org/pointers/

Answer 5

c does not have a built in notion of lists or list comprehension, you have to set up an explicit loop over an array, and have to support the length of the list yourself.

Yes, this is wordier than the python way, but that is because python is handling the details for you.

Data structures that are reasonably well suited to handling notional "lists":

• dynamic arrays (possibly wrapped in a struct to let you hold meta info like the current length and allocated length in the same place)
• linked lists

If you choose an array based solution you will need to either

1. keep track of the current length and pass it to the processing functions
2. use a sentinel to mark the end of the data (which might mean using a larger data type to allow you to specify a sentinel that can not appear in the data)

linked lists can be processed node by node because the have a natural end.