Understanding declaration in C++

Question

I am reading C++ in easy steps and came across a piece of code for references and pointers that I do not understand.

The code is void (* fn) (int& a, int* b) = add;. As far as I know it does not affect the program itself but would like to know what this code does.

#include <iostream>
using namespace std;

void add (int& a, int* b)
{
    cout << "Total: " << (a+ *b) << endl;
}

int main()
{
    int num = 100, sum = 200;
    int rNum = num;
    int* ptr = &num;

    void (* fn) (int& a, int* b) = add;

    cout << "reference: " << rNum << endl;
    cout << "pointer: " << *ptr << endl;

    ptr = &sum;
    cout << "pointer now: " << *ptr << endl;
    add(rNum, ptr);
    return 0;
}

Answer 1

Use the spiral rule:

     +----------------------+
     |  +--+                |
     |  ^  |                |
void (* fn ) (int& a, int* b) = add;
^    |     |                |
|    +-----+                |
+---------------------------+

fn is a pointer to a function taking two arguments (an int& named a and a int* named b) and returning void. The function pointer is copy initialized with the free function add.

So where in your code you have:

add(rNum, ptr);

That could be equivalently replaced by:

fn(rNum, ptr);

Answer 2

fn is a pointer to a function taking, from left to right, an int&, and an int*, that does not return anything.

You are assigning the function add to fn.

You could call the function add through the pointer, using exactly the same syntax as you would if you were use add.

One use of this technique is in the modelling of callback functions. For example, qsort requires a callback function for the sorting predicate. Function pointers are more common in C than in C++ where there are other techniques such as function objects, templates, lambdas, and even std::function.

Answer 3

If you read about the clockwise/spiral rule the declaration is easy to decipher:

You declare a variable fn, which is a pointer, to a function, taking some arguments and returning nothing.

Then you make this function-pointer fn point to the add function.

You can then use the function-pointer instead of calling add directly.

Answer 4

void (* fn) (int& a, int* b) = add; declares a function pointer named fn that points that points to a function that has a signature of void(int&,int*). it then intilizes the pointer to the add() function.

Answer 5

Such complicated declarations are easily read using the right-left rule, which works even when the clockwise spiral rule fails, which does even in case of something as simple as int* a[][10].

void (* fn) (int& a, int* b);

Start with the identifier fn and go from right to left, with the parenthesis flipping the direction. So fn is a pointer to a function taking are reference to int and a pointer to int and the function's return type is void.

It's called reading boustrophedonically :) See this answer for another example.