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

Inequality operators

== Synopses

Declared in `&lt;bsltf&lowbar;allocbitwisemoveabletesttype&period;h&gt;`

Return `true` if the specified iterators do _not_ refer to the same element, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bsltf/operator_not_eq-028.adoc[operator!&equals;](
    xref:BloombergLP/bsltf/TestValuesArrayIterator.adoc[TestValuesArrayIterator&lt;OTHER&lowbar;VALUE&gt;] const&,
    xref:BloombergLP/bsltf/TestValuesArrayIterator.adoc[TestValuesArrayIterator&lt;OTHER&lowbar;VALUE&gt;] const&);
----

[.small]#xref:BloombergLP/bsltf/operator_not_eq-028.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 `SimpleTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-0f4.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 `AllocTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-08.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 `UnionTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-074.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 `WellBehavedMoveOnlyAllocTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

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

Return `true` if the specified iterators do not refer to the same underlying position, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bsltf/operator_not_eq-060.adoc[operator!&equals;](
    xref:BloombergLP/bsltf/InputIterator.adoc[InputIterator&lt;TYPE2&gt;] const&,
    xref:BloombergLP/bsltf/InputIterator.adoc[InputIterator&lt;TYPE2&gt;] const&);
----

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

Return `true` if the specified `lhs` and `rhs` do not refer to the same `TYPE` object and `false` othersise&period;


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

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

Return `true` if the specified `lhs` and `rhs` adaptors are not equal and `false` otherwise&period; Two allocator adaptor instances are not equal if their associated allocator instances are not equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class TYPE1,
    class TYPE2&gt;
bool
xref:BloombergLP/bsltf/operator_not_eq-092.adoc[operator!&equals;](
    xref:BloombergLP/bsltf/StdAllocatorAdaptor.adoc[StdAllocatorAdaptor&lt;TYPE1&gt;] const& lhs,
    xref:BloombergLP/bsltf/StdAllocatorAdaptor.adoc[StdAllocatorAdaptor&lt;TYPE2&gt;] const& rhs);
----

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

Return `true` if the specified iterator and sentinel do _not_ refer to the same element, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bsltf/operator_not_eq-069.adoc[operator!&equals;](
    xref:BloombergLP/bsltf/TestValuesArrayIterator.adoc[TestValuesArrayIterator&lt;OTHER&lowbar;VALUE&gt;] const&,
    xref:BloombergLP/bsltf/TestValuesArraySentinel.adoc[TestValuesArraySentinel&lt;OTHER&lowbar;VALUE&gt;] const&);
----

[.small]#xref:BloombergLP/bsltf/operator_not_eq-069.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 `NonTypicalOverloadsTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

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

Return `true` if the specified sentinel and iterator do _not_ refer to the same element, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bsltf/operator_not_eq-051.adoc[operator!&equals;](
    xref:BloombergLP/bsltf/TestValuesArraySentinel.adoc[TestValuesArraySentinel&lt;OTHER&lowbar;VALUE&gt;] const&,
    xref:BloombergLP/bsltf/TestValuesArrayIterator.adoc[TestValuesArrayIterator&lt;OTHER&lowbar;VALUE&gt;] const&);
----

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

Return `true` if the specified `lhs` and the specified `rhs` do _not_ refer to the same element, and `false` otherwise&period; The behavior is undefined unless `lhs` and `rhs` are comparable&period;


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

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

Return `true` if the specified `lhs` and the specified `rhs` do _not_ refer to the same element, and `false` otherwise&period; The behavior is undefined unless `lhs` and `rhs` are comparable&period;


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

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

Return `true` if the specified `lhs` and the specified `rhs` do _not_ refer to the same element, and `false` otherwise&period; The behavior is undefined unless `lhs` and `rhs` are comparable&period;


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

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

Return an `EvilBoolanType` value that converts to `true` if the specified `lhs` and `rhs` do not have the same value, and a value that converts to `false` otherwise&period; Two `EvilBooleanType` objects do not have the same value if the values resulting from converting each to `bool` do not have the same value&period;


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

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

Return `true` if the specified `lhs` and `rhs` have different underlying test allocators, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class TYPE1,
    class TYPE2,
    bool PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;COPY&lowbar;CONSTRUCTION,
    bool PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;COPY&lowbar;ASSIGNMENT,
    bool PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;SWAP,
    bool PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;MOVE&lowbar;ASSIGNMENT,
    bool IS&lowbar;ALWAYS&lowbar;EQUAL&gt;
bool
xref:BloombergLP/bsltf/operator_not_eq-0c.adoc[operator!&equals;](
    xref:BloombergLP/bsltf/StdStatefulAllocator.adoc[StdStatefulAllocator&lt;TYPE1, PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;COPY&lowbar;CONSTRUCTION, PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;COPY&lowbar;ASSIGNMENT, PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;SWAP, PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;MOVE&lowbar;ASSIGNMENT, IS&lowbar;ALWAYS&lowbar;EQUAL&gt;] const& lhs,
    xref:BloombergLP/bsltf/StdStatefulAllocator.adoc[StdStatefulAllocator&lt;TYPE2, PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;COPY&lowbar;CONSTRUCTION, PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;COPY&lowbar;ASSIGNMENT, PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;SWAP, PROPAGATE&lowbar;ON&lowbar;CONTAINER&lowbar;MOVE&lowbar;ASSIGNMENT, IS&lowbar;ALWAYS&lowbar;EQUAL&gt;] const& rhs);
----

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

Return `false` because `StdTestAllocator` does not hold a state&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class TYPE1,
    class TYPE2&gt;
bool
xref:BloombergLP/bsltf/operator_not_eq-0e.adoc[operator!&equals;](
    xref:BloombergLP/bsltf/StdTestAllocator-05.adoc[StdTestAllocator&lt;TYPE1&gt;] const& lhs,
    xref:BloombergLP/bsltf/StdTestAllocator-05.adoc[StdTestAllocator&lt;TYPE2&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bsltf/operator_not_eq-0e.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 `AllocBitwiseMoveableTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-079.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 `NonOptionalAllocTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-0a.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 `NonDefaultConstructibleTestType` objects do not have the same value if `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-0b1.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 `NonCopyConstructibleTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-05bc.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 `NonAssignableTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-00b.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 `MoveOnlyAllocTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

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

Return `true` if the specified `lhs` and `rhs` objects do not have the same `data()` value, and `false` otherwise&period; Two `MovableTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-0bb.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 `MovableAllocTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-0bc.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 `EmplacableTestType` objects do not have the same value if any of their corresponding attributes do not have the same value&period;


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

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

Return `false`&semi; the copy&sol;move state is _not_ a salient attribute, so all `CopyMoveTracker` objects compare equal&period; Note that this operator is called implicitly if a client class defines a defaulted comparison operator (C&plus;&plus;20), but will not be selected by overload resolution for a derived class having no comparison operator&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
constexpr
bool
xref:BloombergLP/bsltf/operator_not_eq-0f0.adoc[operator!&equals;](
    xref:BloombergLP/bsltf/CopyMoveTracker.adoc[CopyMoveTracker] const&,
    OTHER const&)
requires bsl&colon;&colon;is&lowbar;same&lt;CopyMoveTracker, OTHER&gt;&colon;&colon;value;
----

[.small]#xref:BloombergLP/bsltf/operator_not_eq-0f0.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 `BitwiseMoveableTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-0d.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 `BitwiseCopyableTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-000.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 `AllocTestType` objects do not have the same value if their `data` attributes are not the same&period;


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

[.small]#xref:BloombergLP/bsltf/operator_not_eq-05bf.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 `AllocEmplacableTestType` objects do not have the same value if any of their corresponding attributes do not have the same value&period;


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

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

Same as the preceding overload with operand order reversed&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bsltf/operator_not_eq-015.adoc[operator!&equals;](
    int a,
    xref:BloombergLP/bsltf/CopyMoveState-0e/Enum.adoc[CopyMoveState::Enum] b);
----

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

Return `true` if the integral values of the specified `a` and `b` do not compare equal&semi; otherwise return `false`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bsltf/operator_not_eq-02c.adoc[operator!&equals;](
    xref:BloombergLP/bsltf/CopyMoveState-0e/Enum.adoc[CopyMoveState::Enum] a,
    int b);
----

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


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