[#BloombergLP-bslstl-BidirectionalIterator]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bslstl.adoc[bslstl]::BidirectionalIterator
:relfileprefix: ../../
:mrdocs:

Given an `ITER_IMP` type that implements a minimal subset of an iterator interface, this template generates a complete iterator that meets all of the requirements of a "bidirectional iterator" in the C++ standard. If `T` is `const`‐qualified, then the resulting type is a constant iterator. `T` shall not be a function, reference type or void. `ITER_IMP` must provide public operations so that, for objects `i` and `j` of type `ITER_IMP`, the following operations are supported: ` ITER_IMP i; default construction ITER_IMP j(i); copy construction i = j assignment ++i increment to next element ‐‐i decrement to previous element i == j // convertible to bool equality comparison *i // reference convertible to T& element access (dereference) `

== Synopsis

Declared in `<bslstl_bidirectionaliterator.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template<
    class T,
    class ITER_IMP,
    class TAG_TYPE = std::bidirectional_iterator_tag>
class BidirectionalIterator
    : public xref:BloombergLP/bslstl/ForwardIterator.adoc[ForwardIterator<T, ITER_IMP, TAG_TYPE>]
----

== Base Classes

[cols="1,4"]
|===
| Name| Description
| `xref:BloombergLP/bslstl/ForwardIterator.adoc[ForwardIterator<T, ITER_IMP, TAG_TYPE>]`
| Given an `ITER_IMP` type that implements a minimal subset of an iterator interface, this template generates a complete iterator that meets all of the requirements of a "forward iterator" in the C++ standard. If `T` is const‐qualified, then the resulting type is a const iterator. `T` shall not be a function, reference type or void. `ITER_IMP` must provide public operations so that, for objects `i` and `j` of type `ITER_IMP`, the following operations are supported: ` ITER_IMP i; Default construction ITER_IMP j(i); Copy construction i = j Assignment ++i Increment to next element i == j // convertible to bool Equality comparison *i // reference convertible to T& Element access (dereference) `
|===

== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/BidirectionalIterator/difference_type.adoc[`difference_type`] 
| Type of the distance between two iterators.
| xref:BloombergLP/bslstl/BidirectionalIterator/iterator_category.adoc[`iterator_category`] 
| Standard iterator category tag for bidirectional iterators.
| xref:BloombergLP/bslstl/BidirectionalIterator/pointer.adoc[`pointer`] 
| Pointer type for the iterator's element type.
| xref:BloombergLP/bslstl/BidirectionalIterator/reference.adoc[`reference`] 
| Reference type for the iterator's element type.
| xref:BloombergLP/bslstl/BidirectionalIterator/value_type.adoc[`value_type`] 
| Type of the value obtained when dereferencing the iterator.
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/BidirectionalIterator/2constructor-09.adoc[`BidirectionalIterator`]         [.small]#[constructor]#
| Constructors
| xref:BloombergLP/bslstl/BidirectionalIterator/operator_assign-05.adoc[`operator=`] 
| Assignment operators
| xref:BloombergLP/bslstl/ForwardIterator/imp-0e.adoc[`imp`] 
| `imp` overloads
| xref:BloombergLP/bslstl/ForwardIterator/operator_star.adoc[`operator*`] 
| Return a reference to the current, modifiable element. The behavior is undefined if this iterator has the past‐the‐end value for an iterator over the underlying sequence.
| xref:BloombergLP/bslstl/BidirectionalIterator/operator_inc.adoc[`operator++`] 
| Increment to the next element. Return a reference to this modifiable iterator. The behavior is undefined if, on entry, this iterator has the past‐the‐end value for an iterator over the underlying sequence.
| xref:BloombergLP/bslstl/BidirectionalIterator/operator_dec.adoc[`operator‐‐`] 
| Decrement to the previous element. Return a reference to this modifiable iterator. The behavior is undefined if, on entry, this iterator has the same value as an iterator the refers to the start of the underlying sequence.
| xref:BloombergLP/bslstl/ForwardIterator/operator_ptr.adoc[`operator‐>`] 
| Return a pointer to the current, modifiable element. The behavior is undefined if this iterator has the past‐the‐end value for an iterator over the underlying sequence.
|===


== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/operator_not_eq-0bc.adoc[`operator!=`]
| Return `true` if the specified `lhs` iterator does not have the same value as the specified `rhs` iterator, and `false` otherwise. Two iterators do not have the same value if (1) they do not refer to the same element and (2) both do not have the past‐the‐end iterator value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.
| xref:BloombergLP/bslstl/operator_not_eq-0d.adoc[`operator!=`]
| Return `true` if the specified `lhs` iterator does not have the same value as the specified `rhs` iterator, and `false` otherwise. Two iterators do not have the same value if (1) they do not refer to the same element and (2) both do not have the past‐the‐end iterator value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.
| xref:BloombergLP/bslstl/operator_inc-008.adoc[`operator++`]
| Increment the specified `iter` to the next element. Return the previous value of `iter`. The behavior is undefined if, on entry, `iter` has the past‐the‐end value for an iterator of the underlying sequence.
| xref:BloombergLP/bslstl/operator_inc-07.adoc[`operator++`]
| Increment the specified `iter` to the next element. Return the previous value of `iter`. The behavior is undefined if, on entry, `iter` has the past‐the‐end value for an iterator of the underlying sequence.
| xref:BloombergLP/bslstl/operator_dec-08.adoc[`operator‐‐`]
| Decrement the specified `iter` to the previous element. Return the previous value of `iter`. The behavior is undefined if, on entry, `iter` has the same value as an iterator to the start of the underlying sequence.
| xref:BloombergLP/bslstl/operator_eq-066.adoc[`operator==`]
| Return `true` if the specified `lhs` iterator has the same value as the specified `rhs` iterator, and `false` otherwise. Two iterators have the same value if they refer to the same element, or both have the past‐the‐ end value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.
| xref:BloombergLP/bslstl/operator_eq-08.adoc[`operator==`]
| Return `true` if the specified `lhs` iterator has the same value as the specified `rhs` iterator, and `false` otherwise. Two iterators have the same value if they refer to the same element, or both have the past‐the‐ end value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.
|===

== Derived Classes

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/RandomAccessIterator.adoc[`RandomAccessIterator`] 
| Given an `ITER_IMP` type that implements a minimal subset of an iterator interface, this template generates a complete iterator that meets all of the requirements of a "random‐access iterator" in the C++ standard. If `T` is const‐qualified, then the resulting type is a const iterator. `T` shall not be a function, reference type or void. `ITER_IMP` must provide public operations so that, for objects `i` and `j` of type `ITER_IMP` and `n` of an integral type, the following operations are supported: ` ITER_IMP i; default construction ITER_IMP j(i); copy construction i = j assignment ++i increment to next element ‐‐i decrement to previous element i += n increment by n elements i ‐= n decrement by n elements j ‐ i // convertible to ptrdiff_t distance from i to j i == j // convertible to bool equality comparison i < j // convertible to bool less‐than comparison *i // reference convertible to T& element access (dereference) `
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#