std::bind

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=

Pairs and tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

Swap, forward and move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

Function objects

Function wrappers
function (C++11)
mem_fn (C++11)
bad_function_call (C++11)
Bind
bind (C++11)
is_bind_expression (C++11)
is_placeholder (C++11)
_1, _2, _3, ... (C++11)
Reference wrappers
reference_wrapper (C++11)
refcref (C++11)(C++11)
Operator wrappers
plus minus negate multiplies divides modulus logical_and logical_or logical_not	equal_to not_equal_to greater less greater_equal less_equal bit_and bit_or bit_xor bit_not (C++14)
Negators
unary_negate binary_negate	not1 not2
Deprecated binders and adaptors
unary_function (deprecated)
binary_function (deprecated)
ptr_fun (deprecated)
pointer_to_unary_function (deprecated)
pointer_to_binary_function (deprecated)
mem_fun (deprecated)
mem_fun_tmem_fun1_tconst_mem_fun_tconst_mem_fun1_t (deprecated)(deprecated)(deprecated)(deprecated)
mem_fun_ref (deprecated)
mem_fun_ref_tmem_fun1_ref_tconst_mem_fun_ref_tconst_mem_fun1_ref_t (deprecated)(deprecated)(deprecated)(deprecated)
binder1stbinder2nd (deprecated)(deprecated)
bind1stbind2nd (deprecated)(deprecated)

 

Defined in header <functional>
template< class F, class... Args > /*unspecified*/ bind( F&& f, Args&&... args );	(1)	(since C++11)
template< class R, class F, class... Args > /*unspecified*/ bind( F&& f, Args&&... args );	(2)	(since C++11)

The function template bind generates a forwarding call wrapper for f. Calling this wrapper is equivalent to invoking f with some of its arguments bound to args.

Internally, the wrapper holds a member object of type std::decay<F>::type constructed from std::forward<F>(f), and one object per each of args..., of type std::decay<Arg_i>::type, similarly constructed from std::forward<Arg_i>(arg_i).

Parameters

f	-	invocable object (function object, pointer to function, reference to function, pointer to member function, or pointer to member data) that will be bound to some arguments
args	-	list of arguments to bind, with the unbound arguments replaced by the placeholders _1, _2, _3... of namespace std::placeholders

Return value

A function object of unspecified type T, for which std::is_bind_expression<T>::value == true, and which can be stored in std::function. The object is movable if f and all args are movable, and is copyable otherwise. The type defines the following members:

std::bind return type

Member type result_type

1) If F is a pointer to function or a pointer to member function, result_type is the return type of F. If F is a class type with nested typedef result_type, then result_type is F::result_type. Otherwise no result_type is defined.

2) result_type is exactly R.

Member function operator()

Given an object g obtained from an earlier call to bind, when it is invoked in a function call expression g(u1, u2, ... uM), an invocation of the stored object of type std::decay<F>::type takes place, with arguments defined as follows:

• If the argument is of type std::reference_wrapper<T> (e.g. std::ref or std::cref) was used in the initial call to bind, then the reference T& stored in the bound argument is passed to the invocable object.
• If std::is_bind_expression<T>::value == true (i.e. another bind subexpression was used as an argument in the initial call to bind), then that bind subexpression is invoked immediately and its result is passed to the invocable object. If the bind subexpression has any placeholder arguments, they are picked from u1, u2, ....
• If std::is_placeholder<T>::value != 0 (i.e., std::placeholders::_1, _2, _3, ... was used as the argument to the initial call to bind), then the argument indicated by the placeholder (u1 for _1, u2 for _2, etc) is passed to the invocable object as std::forward<Uj>(uj).
• Otherwise, the stored argument is passed to the invocable object as-is.

If some of the arguments that are supplied in the call to g() are not matched by any placeholders stored in g, the unused arguments are evaluated and discarded.

Exceptions

Only throws if construction of std::decay<F>::type from std::forward<F>(f) throws, or any of the constructors for std::decay<Arg_i>::type from the corresponding std::forward<Arg_i>(arg_i) throws where Arg_i is the ith type and arg_i is the ith argument in Args... args.

Notes

The arguments to bind are copied or moved, and are never passed by reference unless wrapped in std::ref or std::cref.

Duplicate placeholders in the same bind expression (multiple _1's for example) are allowed, but the results are only well defined if the corresponding argument (u1) is an lvalue or non-movable rvalue.

Example

Run this code

#include <random>
#include <iostream>
#include <functional>
 
void f(int n1, int n2, int n3, const int& n4, int n5)
{
    std::cout << n1 << ' ' << n2 << ' ' << n3 << ' ' << n4 << ' ' << n5 << '\n';
}
 
int g(int n1)
{
    return n1;
}
 
struct Foo {
    void print_sum(int n1, int n2)
    {
        std::cout << n1+n2 << '\n';
    }
    int data = 10;
};
 
int main()
{
    using namespace std::placeholders;  // for _1, _2, _3...
 
    // demonstrates argument reordering and pass-by-reference
    int n = 7;
    // (_1 and _2 are from std::placeholders, and represent future
    // arguments that will be passed to f1)
    auto f1 = std::bind(f, _2, _1, 42, std::cref(n), n);
    n = 10;
    f1(1, 2, 1001); // 1 is bound by _1, 2 is bound by _2, 1001 is unused
 
    // nested bind subexpressions share the placeholders
    auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5);
    f2(10, 11, 12);
 
    // common use case: binding a RNG with a distribution
    std::default_random_engine e;
    std::uniform_int_distribution<> d(0, 10);
    std::function<int()> rnd = std::bind(d, e);
    for(int n=0; n<10; ++n)
        std::cout << rnd() << ' ';
    std::cout << '\n';
 
    // bind to a member function
    Foo foo;
    auto f3 = std::bind(&Foo::print_sum, &foo, 95, _1);
    f3(5);
 
    // bind to member data
    auto f4 = std::bind(&Foo::data, _1);
    std::cout << f4(foo) << '\n';
}

Output:

2 1 42 10 7
12 12 12 4 5
1 5 0 2 0 8 2 2 10 8
100
10

See also

_1, _2, _3, _4, ... (C++11)	placeholders for the unbound arguments in a std::bind expression (constant)
mem_fn (C++11)	creates a function object out of a pointer to a member (function template)