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

Inequality operators

== Synopses

Declared in `&lt;bdlc&lowbar;bitarray&period;h&gt;`


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;&gt;
bool
xref:BloombergLP/bdlc/operator_not_eq-0a.adoc[operator!&equals;&lt;&gt;](
    xref:BloombergLP/bdlc/PackedIntArrayConstIterator.adoc[PackedIntArrayConstIterator] const&,
    xref:BloombergLP/bdlc/PackedIntArrayConstIterator.adoc[PackedIntArrayConstIterator] const&);
----

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

Return `true` if the specified `lhs` and `rhs` iterators do not have the same value and `false` otherwise&period; Two `PackedIntArrayConstIterator` iterators do not have the same value if they do not refer to the same array, or do not have the same index&period;


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

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

Return `true` if the specified `lhs` and `rhs` arrays do not have the same value, and `false` otherwise&period; Two `PackedIntArray` arrays do not have the same value if they do not have the same length, or if any corresponding elements (those at the same indices) do not have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlc/operator_not_eq-07.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/PackedIntArray-0b.adoc[PackedIntArray&lt;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlc/PackedIntArray-0b.adoc[PackedIntArray&lt;TYPE&gt;] const& rhs);
----

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

Return `true` if the specified `lhs` and `rhs` arrays do not have the same value, and `false` otherwise&period; Two arrays do not have the same value if they do not have the same length, or there is at least one valid index position at which corresponding bits do not have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlc/operator_not_eq-008.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/BitArray.adoc[BitArray] const& lhs,
    xref:BloombergLP/bdlc/BitArray.adoc[BitArray] const& rhs);
----

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

Return whether the iterators refer to different positions (see free `operator!&equals;`)&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;&gt;
bool
xref:BloombergLP/bdlc/operator_not_eq-01b.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/CompactedArray_ConstIterator.adoc[CompactedArray&lowbar;ConstIterator] const&,
    xref:BloombergLP/bdlc/CompactedArray_ConstIterator.adoc[CompactedArray&lowbar;ConstIterator] const&);
----

[.small]#xref:BloombergLP/bdlc/operator_not_eq-01b.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` iterators do not have the same value, and `false` otherwise&period; Two `CompactedArray&lowbar;ConstIterator` iterators do not have the same value if one has the default value and the other does not, or neither has the default value and they do not reference the same location in the same array&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlc/operator_not_eq-047d.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/CompactedArray_ConstIterator.adoc[CompactedArray&lowbar;ConstIterator&lt;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlc/CompactedArray_ConstIterator.adoc[CompactedArray&lowbar;ConstIterator&lt;TYPE&gt;] const& rhs);
----

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

Return `true` if the underlying object value of the specified `lhs` is not the same as the underlying object value of the specified `rhs`, and `false` otherwise&period; Note that the reference counts are intentionally ignored&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlc/operator_not_eq-007.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/CompactedArray_CountedValue.adoc[CompactedArray&lowbar;CountedValue&lt;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlc/CompactedArray_CountedValue.adoc[CompactedArray&lowbar;CountedValue&lt;TYPE&gt;] const& rhs);
----

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

Return `true` if the specified `lhs` and `rhs` arrays do not have the same value, and `false` otherwise&period; Two `CompactedArray` arrays do not have the same value if they do not have the same length, or if any corresponding elements (those at the same indices) do not have the same value&period;


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

[.small]#xref:BloombergLP/bdlc/operator_not_eq-0b4.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 `FlatHashTable` objects do not have the same value if they do not have the same number of entries, or that for some entry contained in `lhs` there is not a entry in `rhs` having the same value&period; Note that this method requires the (template parameter) type `ENTRY` to be equality&hyphen;comparable&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY,
    class ENTRY,
    class ENTRY&lowbar;UTIL,
    class HASH,
    class EQUAL&gt;
bool
xref:BloombergLP/bdlc/operator_not_eq-0be.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/FlatHashTable.adoc[FlatHashTable&lt;KEY, ENTRY, ENTRY&lowbar;UTIL, HASH, EQUAL&gt;] const& lhs,
    xref:BloombergLP/bdlc/FlatHashTable.adoc[FlatHashTable&lt;KEY, ENTRY, ENTRY&lowbar;UTIL, HASH, EQUAL&gt;] const& rhs);
----

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

Return whether the maps differ in key&sol;value contents&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;&gt;
bool
xref:BloombergLP/bdlc/operator_not_eq-06.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/FlatHashMap.adoc[FlatHashMap] const&,
    xref:BloombergLP/bdlc/FlatHashMap.adoc[FlatHashMap] const&);
----

[.small]#xref:BloombergLP/bdlc/operator_not_eq-06.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 `FlatHashMap` objects do not have the same value if their sizes are different or one contains an element equal to no element of the other&period; The hash and equality functors are not involved in the comparison&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY,
    class VALUE,
    class HASH,
    class EQUAL&gt;
bool
xref:BloombergLP/bdlc/operator_not_eq-0b1.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/FlatHashMap.adoc[FlatHashMap&lt;KEY, VALUE, HASH, EQUAL&gt;] const& lhs,
    xref:BloombergLP/bdlc/FlatHashMap.adoc[FlatHashMap&lt;KEY, VALUE, HASH, EQUAL&gt;] const& rhs);
----

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

Return `true` if the specified `lhs` and `rhs` queues do not have the same value, and `false` otherwise&period; Two queues do not have the same value if they have different lengths or differ in at least one index position&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class T&gt;
bool
xref:BloombergLP/bdlc/operator_not_eq-0f.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/Queue.adoc[Queue&lt;T&gt;] const& lhs,
    xref:BloombergLP/bdlc/Queue.adoc[Queue&lt;T&gt;] const& rhs);
----

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

Return `true` if `lhs` and `rhs` do not have the same value and `false` otherwise&period; Two iterators do not have the same value if they do not refer to the same element of the same container or if one has the end iterator value of a container and the other refers to an element (not the end) of the same container&period; The behavior is undefined unless `lhs` and `rhs` refer to the same container and are non&hyphen;singular (i&period;e&period;, are not default&hyphen;constructed or copies of singular iterators)&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlc/operator_not_eq-09.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/IndexClerkIter.adoc[IndexClerkIter] const& lhs,
    xref:BloombergLP/bdlc/IndexClerkIter.adoc[IndexClerkIter] const& rhs);
----

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

Return `true` if the specified `lhs` and `rhs` index clerks do not have the same value, and `false` otherwise&period; Two `IndexClerk` objects do not have the same value if they do not have the same `nextNewIndex()`, or might generate different sequences of integer indices&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlc/operator_not_eq-014.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/IndexClerk.adoc[IndexClerk] const& lhs,
    xref:BloombergLP/bdlc/IndexClerk.adoc[IndexClerk] const& rhs);
----

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

Return whether the sets differ in contents&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;&gt;
bool
xref:BloombergLP/bdlc/operator_not_eq-0473.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/FlatHashSet.adoc[FlatHashSet] const&,
    xref:BloombergLP/bdlc/FlatHashSet.adoc[FlatHashSet] const&);
----

[.small]#xref:BloombergLP/bdlc/operator_not_eq-0473.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 `FlatHashSet` objects do not have the same value if their sizes are different or one contains an element equal to no element of the other&period; The hash and equality functors are not involved in the comparison&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY,
    class HASH,
    class EQUAL&gt;
bool
xref:BloombergLP/bdlc/operator_not_eq-01f.adoc[operator!&equals;](
    xref:BloombergLP/bdlc/FlatHashSet.adoc[FlatHashSet&lt;KEY, HASH, EQUAL&gt;] const& a,
    xref:BloombergLP/bdlc/FlatHashSet.adoc[FlatHashSet&lt;KEY, HASH, EQUAL&gt;] const& b);
----

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


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