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

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.