C ++模板中的函数签名

Question

The std::function class is templated in such a way that when we want it to wrap a function like the following:

void printInt(int integer)
{
    std::cout << int << '\n';
}

We use a std::function<void(int)> . Until recently I thought this was an odd nuance of the class, but a class I found while searching for delegate implementation in C++ uses a similar syntax.

What exactly is void(int) , and what do we call it in technical terms? It seems to be the standard way of saying " a function that takes an int, and returns void " in codespeak, but my gut instinct says that's horribly oversimplified.

Secondly, I've noticed that when I see templates using this syntax they use variadic templates to allow multiple function signatures to be matched. From the link above:

template <typename T> class delegate;

template<class R, class ...A>
class delegate<R (A...)>
{
...

What is the reason for declaring the function as such instead of simply using the following:

template<class R, class ...A>
class delegate
{
...

Answer 1

The template parameter to std::function<Signature> is simply the type of a function, ie, its signature. It uses the same notation as any function declaration except that it isn't named and the name is left out. You may have come across function pointers which use the same notation but the function signature is used for a pointer.

The reason std::function<Signature> (and apparently delegate<Signature> ) are implemented using template specialization is to yield a nicer type:

template <typename T> class function;
template <typename R, typename... Args>
class function {
public:
    R operator()(Args...);
    // ...
};

template <typename R, typename... Args>
class other {
public:
    R operator()(Args...);
    // ...
};

int main() {
    function<int(double, char)> f;
    other<int, double, char>    o;
}

Since the primary template for function<T> takes one type as argument, using the specialization the argument can be a normal function type. On the other hand, the same isn't done for other<T...> which, thus, gets a list of types.

It is worth nothing that std::function<T> objects can be passed around quite easily without any need to deal with many template arguments: since the function's signature is just a type, this class template takes just one template argument.