Pointers to Functions (C++) - c++

Question

I am studying a C++ tutorial. I can't understand this example on Pointers to Functions.
Here it is:-
// pointer to functions
#include <iostream>
using namespace std;
int addition (int a, int b)
{ return (a+b); }
int subtraction (int a, int b)
{ return (a-b); }
int operation (int x, int y, int (*functocall)(int,int))
{
int g;
g = (*functocall)(x,y);
return (g);
}
int main ()
{
int m,n;
int (*minus)(int,int) = subtraction;
m = operation (7, 5, addition);
n = operation (20, m, minus);
cout <<n;
return 0;
}
The lines "m = operation (7, 5, addition);" and "n = operation (20, m, minus);" are treated the same way, but while minus has been declared as a pointer to function, addition hasn't. So, how did they both work the same way?

Answer 1

Using a function name as an argument parameter in a function call, or on the right-hand side of the assignment operator in C/C++, causes a conversion to a function pointer to the original function.
So for instance if you have a function like
void my_function(int a, int b);
If you use the identifier my_function on the right-hand side of the assignment operator like this:
void (*my_function_ptr)(int, int) = my_function;
Then my_function implicitly converts from a function object to a function pointer of type void (*)(int, int), initializing the identifier my_function_ptr so that it points to my_function. The same situation would also occur when passing my_function to another function like:
void another_function(int, void (*)(int, int));
another_function(5, my_function);
In the call to another_function(), the identifier my_function is again converted to a pointer to the original function.
Finally, keep in mind this only occurs if you simply pass the identifier name to a function argument, or put it on the right-hand side of the assignment operator. Adding a function call using the () symbols and an optional argument list (i.e., my_function(5, 6)) will evaluate the function, not cause a conversion to a function pointer.

Answer 2

The type of addition is int (&)(int,int) which can decay into a pointer of type int (*)(int,int) which is same as that of operation function's third parameter. So you can pass addition as third argument to the function operation.
The type of subtraction is also the same as that of addition. In your code, the address of subtraction is first stored as local variable of the compatible type, and then that variable is passed as argument to operation function.
In case of addition, it's address is not stored as local variable, instead its passed as such to operation. Its initializing the function's third parameter directly with the function's address, without using any local variable.
A conversion from int (&)(int,int) to int (*)(int,int) occurs in both cases. Its just that with substration, the conversion occurs when initializing the local variable, and with addition, the conversion occurs when initializing the function parameter.
An analogy would be this:
void f(double a, double b) {}
int main()
{
double x = 100;//first store 100 in a local variable
f(x, 100); //pass the local variable as first arg,
//and pass 100 as second arg without using any local variable.
}
Note the type of 100 is int, so it first converts to double type, which is then stored as local variable x, which in turn is passed to the function f as first argument. And the second argument 100 is passed directly to the function, so even now it first converts to double and then it initializes b (the second parameter of the function).
Again, a conversion from int to double occurs in both cases. Its just that first argument conversion occurs when initializing the local variable x, and second argument conversion occurs when initializing the second parameter of the function.

Answer 3

name of the function in C is resolved to its address. So this works:
int (*minus)(int,int) = subtraction;

Answer 4

Both solutions work: the third argument of "operation" must be a function pointer.
Please note that the ampersand is optional:
m = operation (7, 5, &addition);
also works.

Answer 5

By passing "addition" to operation() you're effectively assigning it to "functocall". It's exactly the same as assigning "subtraction" to "minus". They work the same way because they are the same.
The real question is, why don't you need an ampersand (&) to take the function's address?
p.s. Apart from the gratuitous use of iostream, namespace and cout, this is actually a C tutorial. Right?

Answer 6

C++ provides implicit function-to-pointer conversion (see 4.3 in C++ 2003 standard). In your example, it is used both for assignment of subtraction to minus and for conversion of addition to the parameter type accepted by operation. So essentially both calls are done the same way, just in one case you explicitly created an intermediate variable of type pointer-to-function. And in both cases an optimizing compiler will simply pass the address of a corresponding function into operation.