# logical_and<T>

Category: functors | Component type: type

### Description

`Logical_and<T>` is a function object; specifically, it is an Adaptable Binary Predicate, which means it is a function object that tests the truth or falsehood of some condition. If `f` is an object of class `logical_and<T>` and `x` and `y` are objects of class `T` (where `T` is convertible to `bool`) then `f(x,y)` returns true if and only if both `x` and `y` are `true`. [1]

### Example

Finds the first element in a list that lies in the range from 1 to 10.

    list<int> L;
    ...
    list<int>::iterator in_range =
         find_if(L.begin(), L.end(),
                 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
--- | --- | ---
`T` | The type of `logical_and`'s arguments |

### Model of

Adaptable Binary Predicate, DefaultConstructible

### Type requirements

`T` must be convertible to `bool`.

### Public base classes

`binary_function<T, T, bool>`

### Members

Member | Where defined | Description
--- | --- | ---
`first_argument_type` | Adaptable Binary Function | The type of the first argument: `T`
`second_argument_type` | Adaptable Binary Function | The type of the second argument: `T`
`result_type` | Adaptable Binary Function | The type of the result: `bool`
`bool operator()(const T& x, const T& y) const` | Binary Function | Function call operator. The return value is `x && y`.
`logical_and()` | Default Constructible | The default constructor.

### New members

All of `logical_and`'s members are defined in the Adaptable Binary Function and Default Constructible requirements. `Logical_and` does not introduce any new members.

### Notes

[1] `Logical_and` and `logical_or` are not very useful by themselves. They are mainly useful because, when combined with the function object adaptor `binary_compose`, they perform logical operations on other function objects.

### See also

The function object overview, `logical_or`, `logical_not`.

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