# unary_negate<AdaptablePredicate>

Categories: functors, adaptors | Component type: type

### Description

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

### Example

Finds the first element in a list that does not lie in the range from 1 to 10.

    list<int> L;
    ...
    list<int>::iterator in_range =
         find_if(L.begin(), L.end(),
                 not1(compose2(logical_and<bool>(),
                               bind2nd(greater_equal<int>(), 1),
                               bind2nd(less_equal<int>(), 10))));
    assert(in_range == L.end() || !(*in_range >= 1 && *in_range <= 10));

### Definition

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

### Template parameters

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

### Model of

Adaptable Predicate

### Type requirements

`AdaptablePredicate` must be a model of Adaptable Predicate.

### Public base classes

`unary_function<AdaptablePredicate::argument_type, bool>`

### Members

Member | Where defined | Description
--- | --- | ---
`argument_type` | Adaptable Unary Function | The type of the argument: `AdaptablePredicate::argument_type`
`result_type` | Adaptable Unary Function | The type of the result: `bool`
`bool operator()(argument_type)` | Unary Function | Function call operator.
    unary_negate(const AdaptablePredicate& pred)
| `unary_negate` | See below.
    template <class AdaptablePredicate>
    unary_negate<AdaptablePredicate>
    not1(const AdaptablePredicate& pred);
| `unary_negate` | See below.

### New members

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

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

### Notes

[1] Strictly speaking, `unary_negate` is redundant. It can be constructed using the function object `logical_not` and the adaptor `unary_compose`.

### See also

The function object overview, Adaptable Predicate, Predicate, `binary_negate`, `unary_compose`, `binary_compose`

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