std:: binder1st, std:: binder2nd

From cppreference.com

Function wrappers
function (C++11)
move_only_function (C++23)
copyable_function (C++26)
function_ref (C++26)
mem_fn (C++11)
bad_function_call (C++11)

Partial function application
bind_front bind_back (C++20) (C++23)
bind (C++11)
is_bind_expression (C++11)
is_placeholder (C++11)
_1, _2, _3, ... (C++11)

Function invocation
invoke invoke_r (C++17) (C++23)
Identity function object
identity (C++20)

Reference wrappers
reference_wrapper (C++11)
ref cref (C++11) (C++11)
unwrap_reference unwrap_ref_decay (C++20) (C++20)

Operator wrappers

plus
minus
negate
multiplies
divides
modulus
bit_and
bit_or
bit_not (C++14)
bit_xor

equal_to
not_equal_to
greater
less
greater_equal
less_equal
logical_and
logical_or
logical_not

Transparent operator wrappers

plus <> (C++14)
minus <> (C++14)
negate <> (C++14)
multiplies <> (C++14)
divides <> (C++14)
modulus <> (C++14)
bit_and <> (C++14)
bit_or <> (C++14)
bit_not <> (C++14)
bit_xor <> (C++14)

equal_to <> (C++14)
not_equal_to <> (C++14)
greater <> (C++14)
less <> (C++14)
greater_equal <> (C++14)
less_equal <> (C++14)
logical_and <> (C++14)
logical_or <> (C++14)
logical_not <> (C++14)

Negators
not_fn (C++17)
Searchers
default_searcher (C++17)
boyer_moore_searcher (C++17)
boyer_moore_horspool_searcher (C++17)

Constrained comparators
ranges::equal_to (C++20)
ranges::not_equal_to (C++20)
ranges::greater (C++20)
ranges::less (C++20)
ranges::greater_equal (C++20)
ranges::less_equal (C++20)
compare_three_way (C++20)

Old binders and adaptors

unary_function ( until C++17* )
binary_function ( until C++17* )
ptr_fun ( until C++17* )
pointer_to_unary_function ( until C++17* )
pointer_to_binary_function ( until C++17* )
mem_fun ( until C++17* )
mem_fun_t mem_fun1_t const_mem_fun_t const_mem_fun1_t ( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
not1 ( until C++20* )
not2 ( until C++20* )

binder1st binder2nd ( until C++17* ) ( until C++17* )
bind1st bind2nd ( until C++17* ) ( until C++17* )

mem_fun_ref ( until C++17* )
mem_fun_ref_t mem_fun1_ref_t const_mem_fun_ref_t const_mem_fun1_ref_t ( until C++17* ) ( until C++17* ) ( until C++17* ) ( until C++17* )
unary_negate ( until C++20* )
binary_negate ( until C++20* )

Defined in header `<functional>`
template < class Fn > class binder1st : public std:: unary_function < typename Fn :: second_argument_type , typename Fn :: result_type > { protected : Fn op ; typename Fn :: first_argument_type value ; public : binder1st ( const Fn & fn, const typename Fn :: first_argument_type & value ) ; typename Fn :: result_type operator ( ) ( const typename Fn :: second_argument_type & x ) const ; typename Fn :: result_type operator ( ) ( typename Fn :: second_argument_type & x ) const ; } ;	(1)	(deprecated in C++11) (removed in C++17)
template < class Fn > class binder2nd : public std:: unary_function < typename Fn :: first_argument_type , typename Fn :: result_type > { protected : Fn op ; typename Fn :: second_argument_type value ; public : binder2nd ( const Fn & fn, const typename Fn :: second_argument_type & value ) ; typename Fn :: result_type operator ( ) ( const typename Fn :: first_argument_type & x ) const ; typename Fn :: result_type operator ( ) ( typename Fn :: first_argument_type & x ) const ; } ;	(2)	(deprecated in C++11) (removed in C++17)

A function object that binds an argument to a binary function.

The value of the parameter is passed to the object at the construction time and stored within the object. Whenever the function object is invoked though operator() , the stored value is passed as one of the arguments, the other argument is passed as an argument of operator() . The resulting function object is a unary function.

1) Binds the first parameter to the value value given at the construction of the object.

2) Binds the second parameter to the value value given at the construction of the object.

Example

Run this code

#include <cmath>
#include <functional>
#include <iostream>
#include <vector>
 
const double pi = std::acos(-1); // use std::numbers::pi in C++20
 
int main()
{
    // deprecated in C++11, removed in C++17
    auto f1 = std::bind1st(std::multiplies<double>(), pi / 180.0);
 
    // C++11 replacement
    auto f2 = [](double a) { return a * pi / 180.0; };
 
    for (double n : {0, 30, 45, 60, 90, 180})
        std::cout << n << "°\t" << std::fixed << "= "
                  << f1(n) << " rad (using binder)\t= "
                  << f2(n) << " rad (using lambda)\n"
                  << std::defaultfloat;
}

Output:

0°	= 0.000000 rad (using binder)	= 0.000000 rad (using lambda)
30°	= 0.523599 rad (using binder)	= 0.523599 rad (using lambda)
45°	= 0.785398 rad (using binder)	= 0.785398 rad (using lambda)
60°	= 1.047198 rad (using binder)	= 1.047198 rad (using lambda)
90°	= 1.570796 rad (using binder)	= 1.570796 rad (using lambda)
180°	= 3.141593 rad (using binder)	= 3.141593 rad (using lambda)

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 109	C++98	`operator()` could not modify to argument passed to it	added overloads to handle this

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

std:: binder1st, std:: binder2nd

Example

Defect reports

See also

Navigation