Permalink
Reply
There is a C library I sometimes use that has a function that takes two function pointers. However, there are some calculations that are shared between the two functions that would get pointed to. I am hoping to only need to do these calculations once.
The code below sketches out the general idea of what I've tried so far. The function f handles both of the calculations that would be needed, returning a struct. Functions gx and gy can return the field of the struct that is relevant. Both of them could then get fed into the C function as function pointers.
My concern is that f would then get called twice, whereas that wouldn't be the case in a simpler implementation (gx_simple, gy_simple). ldc will optimize the issue away in this simple example, but I worry that might not generally be the case.
How do I ensure that the commonCalculation is only done once?
struct Foo
{
int x;
int y;
}
Foo f(int x, int a)
{
int commonCalculation = a * x;
return Foo(commonCalculation * x, 2 * commonCalculation);
}
int gx(int x, int a) { return f(x, a).x;}
int gy(int x, int a) { return f(x, a).y;}
//int gx_simple(int x, int a) { return a * x * x;}
//int gy_simple(int x, int a) { return 2 * a * x;}
void main() {
import core.stdc.stdio: printf;
printf("the value of x is %i\n", gx(3, 2));
printf("the value of y is %i\n", gy(3, 2));
}
