Q:
Unable to pass reference to function by reference through pointers in C++
I have 2 methods which look like this.
double myfunc1(double *d, double f){
return d * f;
}
double myfunc2(double *d, double *f){
return d * *f;
}
I need to pass an array of reference to function objects created by the above methods to a third method myfunc3() where it is to be called with 2 arrays of references to function.
double result1[2] = {myfunc1, myfunc1};
double result2[2] = {myfunc2, myfunc2};
double *fp = result1;
double *ff = result2;
myfunc3(&fp, &ff);
In myfunc3() I need to pass it like this -
f1_to_n(*(&fp), n)
but if I do so I am getting an error "error: expected primary-expression before 'double'". What I want is not clear to me. Any help will be appreciated. Thanks.
A:
So I see two ways you could do this. I think the question is why can't the function get passed by reference (i.e. not &f2) like you pass the first argument of myfunc2. The answer is, because the way you currently have it written it can't (i.e. it doesn't actually have to take the addresses of the functions as you have it now, it can take the functions themselves directly - since they don't have names of any kind they would be taken as void functions). If this is the way your functions are meant to work then there is really no way to get around that behavior, but if they are supposed to take pointers to functions then we have to just get rid of the type void (as that is no type at all), so we do need to pass by reference to functions of type double (or any other type).
So let's look at some revised versions of the function declarations.
double myfunc1(double d, double f){
return d * f;
}
double myfunc2(double *d, double *f){
return d * *f;
}
As you can see here I took off the void types, which now makes it clear that myfunc2 will need to be called as myfunc2(double*, double*,...) so it will take pointers to functions and pass them by reference to myfunc2. And now we can do this...
double result1[2] = {myfunc1, myfunc1};
double result2[2] = {myfunc2, myfunc2};
double *fp = result1;
double *ff = result2;
myfunc3(fp, ff);
And I think this is what you want.
I would like to add that the *& is unnecessary here, and could just be *ff or *fp or *fp in the above case, it is pretty pointless in this case.
Just another side note, since C++11 you can now pass const reference to functions to the function which can make your calls more generic and clean up the call signatures a bit as well. So you could do this (still in C++11) and keep things more clean looking in the case where you have a function that takes another function by reference.
double myfunc1(double d, double f){
return d * f;
}
double myfunc2(double *d, double *f){
return d * *f;
}
double result1[2] = {myfunc1, myfunc1};
double result2[2] = {myfunc2, myfunc2};
double *fp = result1;
double *ff = result2;
myfunc3(fp, ff, myfunc2);
...
Note that instead of using (*&) as we did above, here we can use (*ff) and this can actually make a big difference in which type of signatures are needed in your code base. For more information see this SO question.
I think I had gotten to the point that you actually wanted to do this, but here is how you could have originally gotten there.
double myfunc1(double d, double f){
return d * f;
}
double myfunc2(double f, double *d){
return d * f;
}
double result1[2] = {myfunc1, myfunc1};
double result2[2] = {myfunc2, myfunc2};
double *fp = result1;
double *ff = result2;
myfunc3(fp, ff, myfunc1);
Here, as you can see there is now no need to even have the second function in the first place, and by changing the type of the first function in the second function you should be able to do the rest of it.
Another benefit of all of this is that you can now leave off the pointers completely and use regular variables so you don't have to worry about pointer assignment etc.
There are so many questions around that are related to the way you are doing this, like this one that is probably a lot like your situation.
A:
I'm not sure I understood correctly the question. What are the reasons to expect myfunc2 to take its arguments by reference (rather than as pointers)?
myfunc2(double *d, double *f){...} is the correct signature of a function that takes two double * references and returns a double * and should be called like myfunc2(&d, &f).
Note however that f2 could receive its arguments by reference and directly return a pointer:
double *myfunc2(double *d, double *f){
*f = *d * *d;
return f;
}
Such a call would be possible as myfunc2(result1, &result2).
The function can however only return one value (a double *, but the function's output can itself be a function). And this makes it necessary to call the function by reference, i.e. to pass the pointers to it:
myfunc3(&fp, &ff);
And such a call is indeed:
myfunc3(result1, result2);
Or more intuitively:
myfunc3(&result1[0], &result2[0]);
Note that a declaration like:
double (*fp)[2];
in the caller corresponds to an expression in the argument list of a function like:
double *(*fp)[2];
in the caller.
By dereferencing a &, you get a pointer to the first element of the array. But the compiler must know at which position that array's first element must be stored (so it must know the dimension of the array). Hence, it cannot deduce the number of parameters (unless you give it this information in some way (see below)).
