[#BloombergLP-bslstl-operator_not_eq-0ac]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bslstl.adoc[bslstl]::operator!&equals;
:relfileprefix: ../../
:mrdocs:

Inequality operators

== Synopses

Declared in `&lt;bslstl&lowbar;bidirectionaliterator&period;h&gt;`

Return `true` if the specified `lhs` iterator does not have the same value as the specified `rhs` iterator, and `false` otherwise&period; 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&hyphen;the&hyphen;end iterator value for the underlying sequence&period; The behavior is undefined unless both iterators refer to the same underlying sequence&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class T1,
    class T2,
    class ITER&lowbar;IMP,
    class TAG&lowbar;TYPE&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-0bc.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/ForwardIterator.adoc[ForwardIterator&lt;T1, ITER&lowbar;IMP, TAG&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bslstl/ForwardIterator.adoc[ForwardIterator&lt;T2, ITER&lowbar;IMP, TAG&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-0bc.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` iterator does not have the same value as the specified `rhs` iterator, and `false` otherwise&period; 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&hyphen;the&hyphen;end iterator value for the underlying sequence&period; The behavior is undefined unless both iterators refer to the same underlying sequence&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class T1,
    class T2,
    class ITER&lowbar;IMP,
    class TAG&lowbar;TYPE&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-0d.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/BidirectionalIterator.adoc[BidirectionalIterator&lt;T1, ITER&lowbar;IMP, TAG&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bslstl/BidirectionalIterator.adoc[BidirectionalIterator&lt;T2, ITER&lowbar;IMP, TAG&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-0d.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` iterator does not have the same value as the specified `rhs` iterator, and `false` otherwise&period; 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&hyphen;the&hyphen;end iterator value for the underlying sequence&period; The behavior is undefined unless both iterators refer to the same underlying sequence&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class T1,
    class T2,
    class ITER&lowbar;IMP,
    class TAG&lowbar;TYPE&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-093.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/RandomAccessIterator.adoc[RandomAccessIterator&lt;T1, ITER&lowbar;IMP, TAG&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bslstl/RandomAccessIterator.adoc[RandomAccessIterator&lt;T2, ITER&lowbar;IMP, TAG&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-093.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise&period; Two `HashTable` objects do not have the same value if they do not have the same number of elements, or if, for any key found in `lhs`, the subset of elements having that key (according to the hash&hyphen;table&apos;s `comparator`) in `lhs` either (1) does not have the same number of elements as the subset of elements having that key in `rhs`, or (2) there exists no permutation of the `lhs` subset where each element compares equal (using `operator&equals;&equals;`) to the corresponding element in the `rhs` subset&period; The behavior is undefined unless both the `hasher` and `comparator` of `lhs` and `rhs` return the same value for every valid input&period; Note that this method requires that the `ValueType` of the parameterized `KEY&lowbar;CONFIG` be &quot;equality&hyphen;comparable&quot; (see &lcub;Requirements on `KEY&lowbar;CONFIG`&rcub;)&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY&lowbar;CONFIG,
    class HASHER,
    class COMPARATOR,
    class ALLOCATOR&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-065.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/HashTable-06.adoc[HashTable&lt;KEY&lowbar;CONFIG, HASHER, COMPARATOR, ALLOCATOR&gt;] const& lhs,
    xref:BloombergLP/bslstl/HashTable-06.adoc[HashTable&lt;KEY&lowbar;CONFIG, HASHER, COMPARATOR, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-065.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and the specified `rhs` iterators do not have the same value and `false` otherwise&period; Two iterators do not have the same value if they refer to the different elements in the same hash table, or if either (but not both) of the iterators are positioned after the end of a hash table bucket&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE&lowbar;TYPE,
    class DIFFERENCE&lowbar;TYPE&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-0bf.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/HashTableBucketIterator.adoc[HashTableBucketIterator&lt;VALUE&lowbar;TYPE, DIFFERENCE&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bslstl/HashTableBucketIterator.adoc[HashTableBucketIterator&lt;VALUE&lowbar;TYPE, DIFFERENCE&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-0bf.adoc[_» more&period;&period;&period;_]#

Same as the preceding overload&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE&lowbar;TYPE,
    class DIFFERENCE&lowbar;TYPE&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-09f.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/HashTableBucketIterator.adoc[HashTableBucketIterator&lt;VALUE&lowbar;TYPE, DIFFERENCE&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bslstl/HashTableBucketIterator.adoc[HashTableBucketIterator&lt;VALUE&lowbar;TYPE const, DIFFERENCE&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-09f.adoc[_» more&period;&period;&period;_]#

Same as the preceding overload&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE&lowbar;TYPE,
    class DIFFERENCE&lowbar;TYPE&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-00.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/HashTableBucketIterator.adoc[HashTableBucketIterator&lt;VALUE&lowbar;TYPE const, DIFFERENCE&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bslstl/HashTableBucketIterator.adoc[HashTableBucketIterator&lt;VALUE&lowbar;TYPE, DIFFERENCE&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-00.adoc[_» more&period;&period;&period;_]#

Same as the preceding overload&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE&lowbar;TYPE,
    class DIFFERENCE&lowbar;TYPE&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-062ef.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/HashTableBucketIterator.adoc[HashTableBucketIterator&lt;VALUE&lowbar;TYPE const, DIFFERENCE&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bslstl/HashTableBucketIterator.adoc[HashTableBucketIterator&lt;VALUE&lowbar;TYPE const, DIFFERENCE&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-062ef.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and the specified `rhs` iterators do not have the same value and `false` otherwise&period; Two iterators do not have the same value if they refer to the different nodes in the same list, or if either (but not both) of the iterators are at the past&hyphen;the&hyphen;end position of the tree&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE&lowbar;TYPE,
    class DIFFERENCE&lowbar;TYPE&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-0a6.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/HashTableIterator.adoc[HashTableIterator&lt;VALUE&lowbar;TYPE, DIFFERENCE&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bslstl/HashTableIterator.adoc[HashTableIterator&lt;VALUE&lowbar;TYPE, DIFFERENCE&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-0a6.adoc[_» more&period;&period;&period;_]#

Same as the preceding overload&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE&lowbar;TYPE,
    class DIFFERENCE&lowbar;TYPE&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-062ee.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/HashTableIterator.adoc[HashTableIterator&lt;VALUE&lowbar;TYPE, DIFFERENCE&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bslstl/HashTableIterator.adoc[HashTableIterator&lt;VALUE&lowbar;TYPE const, DIFFERENCE&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-062ee.adoc[_» more&period;&period;&period;_]#

Same as the preceding overload&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE&lowbar;TYPE,
    class DIFFERENCE&lowbar;TYPE&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-02.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/HashTableIterator.adoc[HashTableIterator&lt;VALUE&lowbar;TYPE const, DIFFERENCE&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bslstl/HashTableIterator.adoc[HashTableIterator&lt;VALUE&lowbar;TYPE, DIFFERENCE&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-02.adoc[_» more&period;&period;&period;_]#

Same as the preceding overload&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE&lowbar;TYPE,
    class DIFFERENCE&lowbar;TYPE&gt;
bool
xref:BloombergLP/bslstl/operator_not_eq-067.adoc[operator!&equals;](
    xref:BloombergLP/bslstl/HashTableIterator.adoc[HashTableIterator&lt;VALUE&lowbar;TYPE const, DIFFERENCE&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bslstl/HashTableIterator.adoc[HashTableIterator&lt;VALUE&lowbar;TYPE const, DIFFERENCE&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bslstl/operator_not_eq-067.adoc[_» more&period;&period;&period;_]#


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