Question

I’m reading some material about function pointer in C++, and come across one function definition which I do not understand.
Standard function definition have the form:

type name (param...)

But the following definition seems a little strange to me. Can anyone explain it to me ?
Thanks.

float (*GetPtr1(const char opCode)) (float, float)<br>
{
    if(opCode == '+')
        return &Plus;
    else
        return &Minus; // default if invalid operator was passed
}

Note: Plus and Minus are two functions with param (float, float) and return a float.

Answer 1

The rule for reading hairy declarations is to start with the leftmost identifier and work your way out, remembering that () and [] bind before * (i.e., *a[] is an array of pointers, (*a)[] is a pointer to an array, *f() is a function returning a pointer, and (*f)() is a pointer to a function):

        GetPtr1                                       -- GetPtr1
        GetPtr1(                 )                    -- is a function 
        GetPtr1(           opCode)                    -- taking a single parameter named opCode
        GetPtr1(const char opCode)                    -- of type const char
       *GetPtr1(const char opCode)                    -- and returning a pointer
      (*GetPtr1(const char opCode)) (            )    -- to a function
      (*GetPtr1(const char opCode)) (float, float)    -- taking two parameters of type float
float (*GetPtr1(const char opCode)) (float, float)    -- and returning float

So, if opCode is equal to ‘+’, GetPtr1 will return a pointer to the function Plus, and if it’s ‘-‘, it will return a pointer to the function Minus.

C and C++ declaration syntax is expression-centric (much as Bjarne would like to pretend otherwise); the form of the declaration should match the form of the expression as it would be used in the code.

If we have a function f that returns a pointer to int and we want to access the value being pointed to, we execute the function and dereference the result:

x = *f();

The type of the expression *f() is int, so the declaration/definition for the function is

int *f() { ... }

Now suppose we have a function f1 that returns a pointer to the function f defined above, and we want to access that integer value by calling f1. We need to call f1, derefence the result (which is the function f), and execute it, and then dereference that result (since f returns a pointer):

x = *(*f1())(); // *f1() == f, so (*f1())() == f() and *(*f1())() == *f()

The type of the expression *(*f1())() is int, so the decaration/definition for f1 needs to be

int *(*f1())() { return f; }