# binary_negate<AdaptableBinaryPredicate>

Categories: functors, adaptors | Component type: type

### Description

`Binary_negate` is a function object adaptor: it is an Adaptable Binary Predicate that represents the logical negation of some other Adaptable Binary Predicate. That is: if `f` is an object of class `binary_negate<AdaptableBinaryPredicate>`, then there exists an object `pred` of class `AdaptableBinaryPredicate` such that `f(x,y)` always returns the same value as `!pred(x,y)`. There is rarely any reason to construct a `binary_negate` directly; it is almost always easier to use the helper function `not2`.

### Example

Finds the first character in a string that is neither `' '` nor `'\n'`.

    char str[MAXLEN];
    ...
    const char* wptr = find_if(str, str + MAXLEN,
                               compose2(not2(logical_or<bool>()),
                                        bind2nd(equal_to<char>(), ' '),
                                        bind2nd(equal_to<char>(), '\n')));
    assert(wptr == str + MAXLEN || !(*wptr == ' ' || *wptr == '\n'));

### Definition

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

### Template parameters

Parameter | Description | Default
--- | --- | ---
`AdaptableBinaryPredicate` | The type of the function object that this `binary_negate` is the logical negation of. |

### Model of

Adaptable Binary Predicate

### Type requirements

`AdaptableBinaryPredicate` must be a model of Adaptable Binary Predicate.

### Public base classes

    binary_function<AdaptableBinaryPredicate::first_argument_type,
                    AdaptableBinaryPredicate::second_argument_type,
                    bool>

### Members

Member | Where defined | Description
--- | --- | ---
`first_argument_type` | Adaptable Binary Function | The type of the first argument: `AdaptableBinaryPredicate::first_argument_type`
`second_argument_type` | Adaptable Binary Function | The type of the second argument: `AdaptableBinaryPredicate::second_argument_type`
`result_type` | Adaptable Binary Function | The type of the result: `bool`
    binary_negate(const AdaptableBinaryPredicate& pred)
| `binary_negate` | See below.
    template <class AdaptableBinaryPredicate>
    binary_negate<AdaptableBinaryPredicate>
    not2(const AdaptableBinaryPredicate& pred);
| `binary_negate` | See below.

### New members

These members are not defined in the Adaptable Binary Predicate requirements, but are specific to `binary_negate`.

Member | Description
--- | ---
    binary_negate(const AdaptableBinaryPredicate& pred)
| The constructor. Creates a `binary_negate<AdaptableBinaryPredicate>` whose underlying predicate is `pred`.
    template <class AdaptableBinaryPredicate>
    binary_negate<AdaptableBinaryPredicate>
    not2(const AdaptableBinaryPredicate& pred);
| If `p` is of type `AdaptableBinaryPredicate` then `not2(p)` is equivalent to `binary_negate<AdaptableBinaryPredicate>(p)`, but more convenient. This is a global function, not a member function.

### Notes

### See also

The function object overview, AdaptablePredicate, Predicate, `unary_negate`, `unary_compose`, `binary_compose`

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