[#BloombergLP-bsltf-operator_eq-049]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bsltf.adoc[bsltf]::operator&equals;&equals;
:relfileprefix: ../../
:mrdocs:

Equality operators

== Synopses

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

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


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

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

Return whether two objects have the same value&period;


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

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

Return whether two objects have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class ALLOC&gt;
bool
xref:BloombergLP/bsltf/operator_eq-03e7.adoc[operator&equals;&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_eq-03e7.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` unions have the same value&period;


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

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

Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise&period;


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

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

Return whether the specified iterators refer to the same position&period;


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

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

Return whether two input iterators refer to the same position&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bsltf/operator_eq-0cb.adoc[operator&equals;&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_eq-0cb.adoc[_» more&period;&period;&period;_]#

Return whether two allocator adaptors compare equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class TYPE1,
    class TYPE2&gt;
bool
xref:BloombergLP/bsltf/operator_eq-099.adoc[operator&equals;&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_eq-099.adoc[_» more&period;&period;&period;_]#

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


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

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

Return whether two objects have the same value&period;


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

[.small]#xref:BloombergLP/bsltf/operator_eq-09a.adoc[_» more&period;&period;&period;_]#

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


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

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

Return `true` if `lhs` and `rhs` refer to the same element&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class VALUE&gt;
bool
xref:BloombergLP/bsltf/operator_eq-08b.adoc[operator&equals;&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_eq-08b.adoc[_» more&period;&period;&period;_]#

Return `true` if `lhs` and `rhs` refer to the same element&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class VALUE&gt;
bool
xref:BloombergLP/bsltf/operator_eq-05f.adoc[operator&equals;&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_eq-05f.adoc[_» more&period;&period;&period;_]#

Return whether sentinel and iterator refer to the same element&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class VALUE&gt;
bool
xref:BloombergLP/bsltf/operator_eq-03ee.adoc[operator&equals;&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_eq-03ee.adoc[_» more&period;&period;&period;_]#

Return whether two objects have the same value&period;


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

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

Return whether two allocators wrap the same underlying allocator&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_eq-04d.adoc[operator&equals;&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_eq-04d.adoc[_» more&period;&period;&period;_]#

Return `true` 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_eq-0e5.adoc[operator&equals;&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_eq-0e5.adoc[_» more&period;&period;&period;_]#

Return whether two objects have the same value&period;


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

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

Return `true` if the specified `lhs` and `rhs` have the same value&period;


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

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

Return whether two objects have the same value&period;


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

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

Return whether two objects have the same value&period;


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

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

Return whether two objects have the same value&period;


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

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

Return whether the two objects have the same value&period;


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

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

Return `true` if the specified `lhs` and `rhs` have the same value&period;


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

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

Return `true` if the specified `lhs` and `rhs` have the same value&period;


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

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

Return whether two `EmplacableTestType` objects have the same value&period;


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

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

Return whether two `CopyMoveTracker` objects have the same value&period;


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

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

Return whether two objects have the same value&period;


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

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

Return whether two objects have the same value&period;


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

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

Return whether two objects have the same value&period;


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

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

Return whether two `AllocEmplacableTestType` objects have the same value&period;


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

[.small]#xref:BloombergLP/bsltf/operator_eq-09e.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_eq-0af1.adoc[operator&equals;&equals;](
    int a,
    xref:BloombergLP/bsltf/CopyMoveState-0e/Enum.adoc[CopyMoveState::Enum] b);
----

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

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


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

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

== Return Value

* `true` if both refer to the same element
* `true` if `lhs` and `rhs` compare equal, else `false`
* `true` if both iterators refer to the same position
* `true` if both iterators refer to the same object
* `true` if both iterators refer to the same element
* an `EvilBooleanType` converting to `true` if the operands are equal
* `true` if `lhs` and `rhs` wrap the same allocator, else `false`
* `true` because `StdTestAllocator` does not hold a state
* `true` if `lhs` and `rhs` have the same value, and `false` otherwise
* `true`
* `true` if `a` and `b` compare equal, else `false`

== Parameters

[cols="1,4"]
|===
| Name| Description
| *lhs*
| iterator to compare
| *rhs*
| sentinel to compare
| *a*
| left&hyphen;hand operand
| *b*
| right&hyphen;hand operand
|===


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