“函数”类型的优点是什么（不是“指向函数的指针”）

Question

Reading the C++ Standard, i see that there are "function" types and "pointer to function" types:

typedef int func(int);     // function
typedef int (*pfunc)(int); // pointer to function
typedef func* pfunc;       // same as above

I have never seen the function types used outside of examples (or maybe i didn't recognize their usage?). Some examples:

func increase, decrease;            // declares two functions
int increase(int), decrease(int);   // same as above

int increase(int x) {return x + 1;} // cannot use the typedef when defining functions
int decrease(int x) {return x - 1;} // cannot use the typedef when defining functions

struct mystruct
{
    func add, subtract, multiply;   // declares three member functions
    int member;
};

int mystruct::add(int x) {return x + member;} // cannot use the typedef
int mystruct::subtract(int x) {return x - member;}

int main()
{
    func k; // the syntax is correct but the variable k is useless!
    mystruct myobject;
    myobject.member = 4;

    cout << increase(5) << ' ' << decrease(5) << '\n'; // outputs 6 and 4
    cout << myobject.add(5) << ' ' << myobject.subtract(5) << '\n'; // 9 and 1
}

Seeing that the function types support syntax that doesn't appear in C (declaring member functions), i guess they are not just a part of C baggage that C++ has to support for backward compatibility.

So is there any use for function types, other than demonstrating some funky syntax?

Answer 1

On the one hand, you seem to be talking about function types in general. On the other hand, it appears that your question is really about the usability of typedef names for function types.

The function types themselves is a fundamental concept built into both C and C++ languages. They are used all the time. You just can't live without them. Every time you declare a function you declare an entity of function type. Every time you use a pointer to a function, you use a pointer to function type. Etc.

As for the possibility of making typedef names for function types... I don't see much use for it. It is, I think, a part of C baggage, that was extended a bit for C++ just because it was easy to do.

As you correctly noted typedef names for function types can be used to declare member functions (and in C++ you can also include const specifier into typedef, as in typedef int MemberType() const; ), but, for example, you can't use this feature with function types passed as template parameters.

Answer 2

boost:function uses that syntax, called "preferred" syntax.
Seems that kind of syntax is not widely used? Comparing to function pointer.

Answer 3

You see it in the new function objects in Boost/TR1/C++0x.

std::function<void()> accepts any object with an operator() that returns void and takes no arguments.

Answer 4

An example of why this is useful is boost , where you see this a lot. For example in the signals2 library:

boost::signals2::signal<void (int, int)> MySignal;

where the above declares a signal that will accept any function that takes two ints and has a void return type.