# std::binder1st, std::binder2nd

> C++ Atlas: `cppatlas.com/w/cpp/utility/functional/binder12` | Source: https://en.cppreference.com/w/cpp/utility/functional/binder12 | Domain: Utility | Standards: C++11, C++17

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

## Official Specification Summary (cppreference)

```cpp
// 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

```cpp
#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:

```text
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 |

### See also

- [`bind1st`](https://en.cppreference.com/w/cpp/utility/functional/bind12) (deprecated in C++11), [`bind2nd`](https://en.cppreference.com/w/cpp/utility/functional/bind12) (removed in C++17): binds one argument to a binary function (function template)

---
Attribution: content from https://en.cppreference.com/w/cpp/utility/functional/binder12 (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.