Why is there only pointer to function instead of var of function?

Question

In C/C++, we can declare/define a type of pointer to function, and then declare/define some variables of this type. But I think it is ambiguity.

For example:

typedef void ( *pFunc )();
// typedef void ( aFunc )();
void theFunc() {
   cout << "theFunc has been called successfully." << endl;
};

int main() {
   pFunc pf0 = theFunc;
   pFunc pf1 = &theFunc;

   pf0();
   ( *pf0 )();
   pf1();
   ( *pf1 )();
};

Theoretically, only pFunc pf1 = &theFunc; and (*pf1)(); are legal, but all of above can pass through compilation.

In Pascal syntax, we need to define vars of function or vars of pointer to a function respectively, and the meaning of them are different and much clearer(at least I think so)!

Moreover, we can't declare/define a var of function instead of a var of pointer to function! I tried follows and get failed.

typedef void ( aFunc )();
aFunc af0 = theFunc;

If with other types such as int/double, there are very strict syntax that restricts us to use them correctly. (If int* is not same as int, why is *pf0 is same as pf0?!)

So, Can I think it is a bug of C/C++ standard?

Answer 1

Some declared types:

// decltype of theFunc is void ()
// decltype of &theFunc is void (*) ()
// decltype of *theFunc is void (&) ()

Now, concerning your code, since a function is implicitly convertible to a pointer to that function, we have:

using pFunc = void(*)();
using rFunc = void(&)();

pFunc p_fct = &theFunc; // no conversion
pFunc p_fct = theFunc;  // conversion lvalue to pointer
pFunc p_fct = *theFunc; // conversion lvalue reference to pointer

rFunc r_fct = *theFunc; // no conversion
rFunc r_fct = theFunc;  // conversion lvalue to lvalue reference
rFunc r_fct = &theFunc; // ERROR: conversion pointer to lvalue reference not allowed

So far the conversions. Now, any object of type pFunc or rFunc is a callable object. Also, note that both (*p_fct) and (*r_fct) are of type rFunc. Therefore, you can call your function as described in the question:

p_fct();    // callable object of type pFunc
r_fct();    // callable object of type rFunc
(*p_fct)(); // callable object of type rFunc
(*r_fct)(); // callable object of type rFunc

Note that the following is equivalent to the above:

using Func = void ();
Func* p_fct = &theFunc; // no conversion
Func& r_fct = *theFunc; // no conversion
p_fct();                // callable of type Func* or pFunc
r_fct();                // callablel of type Func& or rFunc

EDIT To answer to the question: "why them was arranged in this way" from the below comment: functions cannot be copied (as explained in @JohnBurger's answer). This is why your code:

typedef void ( aFunc )();
aFunc af0 = theFunc;

doesn't work. As explained above, you can do the following though:

typedef void ( aFunc )();
aFunc* af0 = &theFunc; // or theFunc, or even *theFunc

Or you could do this:

auto myFct = theFunc;

But keep in mind that the decltype of myFct is still void (*)().

Answer 2

Ignore functions for a second: think about a struct.

You can have a struct, or a pointer to a struct:

typedef struct {
    int x;
    int y;
} Point;

Point origin = { 0, 0 };
Point here   = { 1, 1 };
Point there  = { 2, 2 };

int main() {
   Point  centre  =  origin;
   Point *myPoint = &origin;

   centre  =  here;
   myPoint = &here;

   centre  =  there;
   myPoint = &there;
} // main()

There are three global Points: origin, here and there.

main() has two variables: centre and myPoint.

centre copies the value of origin, here, and there.

myPoint points to origin, here, and there - it does not copy them.

There is a large difference between these two ideas: one copies the whole object, while the other only points to the other object.

Now think about functions. Functions are defined by the compiler in code, and can never be copied. So it makes no sense to have function variables - how large would they be? The only sensible idea is a pointer-to-function - so that is all that the C language provides.

If you want to define a C function typedef, use the following syntax:

// Fn is a function that accepts a char and returns an int
int Fn(char c);

// FnType is the type of a function that accepts a char and returns an int
typedef int FnType(char c);

// Here is the definition of Fn
int Fn(char c) {
    return c + 1;
} // Fn(c)

// Now here is how you can use FnType
int main() {
    FnType *fn = &Fn;
    return fn('A');
} // main()

Answer 3

I think that I have found the answer.

Indeed c++ standard has offered a method to declare a type of function without the help of pointers.

example:

#include <functional>

using AFunc_t = function<void( int )>;

void theFunc( int );

AFunc_t afunc = theFunc;

I hope this could help someone.