# binder2nd<AdaptableBinaryFunction>

Categories: functors, adaptors | Component type: type

### Description

`Binder2nd` is a function object adaptor: it is used to transform an adaptable binary function into an adaptable unary function. Specifically, if `f` is an object of class `binder2nd<AdaptableBinaryFunction>`, then `f(x)` returns `F(x, c)`, where `F` is an object of class `AdaptableBinaryFunction` and where `c` is a constant. Both `F` and `c` are passed as arguments to `binder2nd`'s constructor. [1]

The easiest way to create a `binder2nd` is not to call the constructor explicitly, but instead to use the helper function `bind2nd`.

### Example

Finds the first positive number in a list.

    list<int> L;
    ...
    list<int>::iterator first_positive =
           find_if(L.begin(), L.end(), bind2nd(greater<int>(), 0));
    assert(first_positive == L.end() || *first_positive > 0);

### Definition

Defined in the standard header functional, and in the nonstandard backward-compatibility header function.h.

### Template parameters

Parameter | Description | Default
--- | --- | ---
`AdaptableBinaryFunction` | The type of the binary function whose second argument is being bound to a constant. |

### Model of

Adaptable Unary Function

### Type requirements

`AdaptableBinaryFunction` must be a model of Adaptable Binary Function.

### Public base classes

    unary_function<AdaptableBinaryFunction::first_argument_type,
                   AdaptableBinaryFunction::result_type>

### Members

Member | Where defined | Description
--- | --- | ---
`argument_type` | Adaptable Unary Function | The type of the function object's argument, which is `AdaptableBinaryFunction::first_argument_type`
`result_type` | Adaptable Unary Function | The type of the result: `AdaptableBinaryFunction::result_type`
    result_type operator()(const argument_type& x) const
| Adaptable Unary Function | Function call. Returns `F(x, c)`, where `F` and `c` are the arguments with which this `binder1st` was constructed.
    binder2nd(const AdaptableBinaryFunction& F,
              AdaptableBinaryFunction::second_argument_type c)
| `binder2nd` | See below
    template <class AdaptableBinaryFunction, class T>
    binder2nd<AdaptableBinaryFunction>
    bind2nd(const AdaptableBinaryFunction& F, const T& c);
| `binder2nd` | See below

### New members

These members are not defined in the Adaptable Unary Function requirements, but are specific to `binder2nd`.

Member | Description
--- | ---
    binder2nd(const AdaptableBinaryFunction& F,
              AdaptableBinaryFunction::second_argument_type c)
| The constructor. Creates a `binder2nd` such that calling it with the argument `x` (where `x` is of type `AdaptableBinaryFunction::first_argument_type`) corresponds to the call `F(x, c)`.
    template <class AdaptableBinaryFunction, class T>
    binder2nd<AdaptableBinaryFunction>
    bind2nd(const AdaptableBinaryFunction& F, const T& c);
| If `F` is an object of type `AdaptableBinaryFunction`, then `bind2nd(F, c)` is equivalent to `binder2nd<AdaptableBinaryFunction>(F, c)`, but is more convenient. The type `T` must be convertible to `AdaptableBinaryFunction::second_argument_type`. This is a global function, not a member function.

[1] Intuitively, you can think of this operation as "binding" the second argument of a binary function to a constant, thus yielding a unary function. This is a special case of a closure.

### See also

The function object overview, `binder1st`, Adaptable Unary Function, Adaptable Binary Function

Copyright © 1999 Silicon Graphics, Inc. All Rights Reserved. TrademarkInformation