Understanding std::function and std::bind

Question

I was playing arround with std::function and std::bind and I noticed something unintuitive and I would like to understand it better.

For example:

void fun()
{
}

void hun(std::string) 
{ 
}

int main()
{

   function<void(int)> g = &fun; //This fails as it should in my understanding.

   function<void(int)> f = std::bind(fun); //This works for reasons unknown to me     
   function<void(int, std::string)> h = std::bind(hun); //this doesn't work

return 0;
}

How is it possible to bind a function<void(int)> to a function that is void(). I could then call f(1) and get fun(). I would like to understand how this is done. Going inside Microsoft Visual Studio 2012's implementation of this got me lost in a sea of unreadable macros. so that is why I ask this question here.

Compiles with _clang_ and _g++_ both. +1, interesting situation. — awesoon, Apr 23 '13 at 08:52
@KerrekSB: This is the correct behaviour - I'd rather wonder which stdlib *you* tested the `std::bind(fun)` version with, because that one is buggy. :) — Xeo, Apr 23 '13 at 08:57
possible duplicate of [std::function and std::bind behavior](http://stackoverflow.com/questions/16162402/stdfunction-and-stdbind-behavior) — ecatmur, Apr 23 '13 at 09:03
@pacificator: ideone and liveworkspace have been used in the past. They have a good choice of compilers. — Kerrek SB, Apr 23 '13 at 09:43

Xeo · Accepted Answer · 2013-04-23T10:55:21.770

If you don't use argument placeholders (_1, _2, ...), then any arguments passed to the function object returned from std::bind will just be discarded. With:

std::function<void(int)> f = std::bind(fun, std::placeholders::_1);

I get a (long and ugly) error as expected.

For the people interested in Standardese:

§20.8.9.1.2 [func.bind.bind]

template<class F, class... BoundArgs>
*unspecified* bind(F&& f, BoundArgs&&... bound_args);

p3 Returns: A forwarding call wrapper g with a weak result type (20.8.2). The effect of g(u1, u2, ..., uM) shall be INVOKE(fd, v1, v2, ..., vN, result_of<FD cv (V1, V2, ..., VN)>::type), where cv represents the cv-qualifiers of g and the values and types of the bound arguments v1, v2, ..., vN are determined as specified below.

p10 The values of the bound arguments v1, v2, ..., vN and their corresponding types V1, V2, ..., VN depend on the types TiD derived from the call to bind and the cv-qualifiers cv of the call wrapper g as follows:

if TiD is reference_wrapper<T>, the argument is tid.get() and its type Vi is T&;

if the value of is_bind_expression<TiD>::value is true, the argument is tid(std::forward<Uj>(uj)...) and its type Vi is result_of<TiD cv (Uj...)>::type;

if the value j of is_placeholder<TiD>::value is not zero, the argument is std::forward<Uj>(uj) and its type Vi is Uj&&;

otherwise, the value is tid and its type Vi is TiD cv &.

Further to that, even if std::function f = std::bind(fun); compiles. It is not possible to actually call f: f(); fails to compile. — Peter R, Apr 23 '13 at 09:13
@PeterR: Obviously, because the signature to `f` mandates one argument. :) — Xeo, Apr 23 '13 at 09:14

score 6 · Answer 2 · answered Apr 23 '13 at 09:00

The forwarding call wrapper generated by a call to function template bind can accept any number of extra parameters; these will be ignored. The effective arity and minimal signature of a bind expression is determined by the placeholders used in its construction, and which callable argument(s) they are bound to.

Understanding std::function and std::bind

2 Answers2

Linked