[#bsl-operator_eq-08e]
= xref:bsl.adoc[bsl]::operator&equals;&equals;
:relfileprefix: ../
:mrdocs:

Equality operators

== Synopses

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

Return `true` if the specified `lhs` and `rhs` iterators refer to the same list element or both are the `end()` iterator of the same list&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:bsl/operator_eq-0da.adoc[operator&equals;&equals;](
    xref:bsl/List_Iterator.adoc[List&lowbar;Iterator&lt;T1&gt;] lhs,
    xref:bsl/List_Iterator.adoc[List&lowbar;Iterator&lt;T2&gt;] rhs);
----

[.small]#xref:bsl/operator_eq-0da.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY,
    class HASH,
    class EQUAL,
    class ALLOCATOR&gt;
bool
xref:bsl/operator_eq-0b3.adoc[operator&equals;&equals;](
    xref:bsl/unordered_set-0d2d.adoc[unordered&lowbar;set&lt;KEY, HASH, EQUAL, ALLOCATOR&gt;] const& lhs,
    xref:bsl/unordered_set-0d2d.adoc[unordered&lowbar;set&lt;KEY, HASH, EQUAL, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-0b3.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:bsl/operator_eq-0cb.adoc[operator&equals;&equals;](
    xref:bsl/unordered_map-02b.adoc[unordered&lowbar;map&lt;KEY2, VALUE2, HASH2, EQUAL2, ALLOCATOR2&gt;] const& lhs,
    xref:bsl/unordered_map-02b.adoc[unordered&lowbar;map&lt;KEY2, VALUE2, HASH2, EQUAL2, ALLOCATOR2&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-0cb.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY,
    class VALUE,
    class HASH,
    class EQUAL,
    class ALLOCATOR&gt;
bool
xref:bsl/operator_eq-024.adoc[operator&equals;&equals;](
    xref:bsl/unordered_map-02b.adoc[unordered&lowbar;map&lt;KEY, VALUE, HASH, EQUAL, ALLOCATOR&gt;] const& lhs,
    xref:bsl/unordered_map-02b.adoc[unordered&lowbar;map&lt;KEY, VALUE, HASH, EQUAL, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-024.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:bsl/operator_eq-068.adoc[operator&equals;&equals;](
    xref:bsl/unordered_multimap-0b0.adoc[unordered&lowbar;multimap&lt;KEY2, VALUE2, HASH2, EQUAL2, ALLOCATOR2&gt;] const& lhs,
    xref:bsl/unordered_multimap-0b0.adoc[unordered&lowbar;multimap&lt;KEY2, VALUE2, HASH2, EQUAL2, ALLOCATOR2&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-068.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY,
    class VALUE,
    class HASH,
    class EQUAL,
    class ALLOCATOR&gt;
bool
xref:bsl/operator_eq-08a.adoc[operator&equals;&equals;](
    xref:bsl/unordered_multimap-0b0.adoc[unordered&lowbar;multimap&lt;KEY, VALUE, HASH, EQUAL, ALLOCATOR&gt;] const& lhs,
    xref:bsl/unordered_multimap-0b0.adoc[unordered&lowbar;multimap&lt;KEY, VALUE, HASH, EQUAL, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-08a.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE&lowbar;TYPE,
    class ALLOCATOR&gt;
bool
xref:bsl/operator_eq-0ce.adoc[operator&equals;&equals;](
    xref:bsl/deque-0c.adoc[deque&lt;VALUE&lowbar;TYPE, ALLOCATOR&gt;] const& lhs,
    xref:bsl/deque-0c.adoc[deque&lt;VALUE&lowbar;TYPE, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-0ce.adoc[_» more&period;&period;&period;_]#

Return whether the specified stacks have the same value&semi; see the non&hyphen;member `operator&equals;&equals;` in the `bsl` namespace&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:bsl/operator_eq-00.adoc[operator&equals;&equals;](
    xref:bsl/stack-05.adoc[stack&lt;VAL, CONT&gt;] const& lhs,
    xref:bsl/stack-05.adoc[stack&lt;VAL, CONT&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-00.adoc[_» more&period;&period;&period;_]#

Return whether the operands have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE,
    class CONTAINER&gt;
bool
xref:bsl/operator_eq-0e3.adoc[operator&equals;&equals;](
    xref:bsl/stack-05.adoc[stack&lt;VALUE, CONTAINER&gt;] const& lhs,
    xref:bsl/stack-05.adoc[stack&lt;VALUE, CONTAINER&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-0e3.adoc[_» more&period;&period;&period;_]#

Return `true` if `lhs` and `rhs` are equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class t&lowbar;HEAD,
    class&period;&period;&period; t&lowbar;TAIL&gt;
bool
xref:bsl/operator_eq-058.adoc[operator&equals;&equals;](
    xref:bsl/variant.adoc[variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;] const& lhs,
    xref:bsl/variant.adoc[variant&lt;t&lowbar;HEAD, t&lowbar;TAIL&period;&period;&period;&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-058.adoc[_» more&period;&period;&period;_]#

Return whether the specified queues have the same value&semi; see the non&hyphen;member `operator&equals;&equals;` in the `bsl` namespace&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:bsl/operator_eq-09b.adoc[operator&equals;&equals;](
    xref:bsl/queue-0a5.adoc[queue&lt;VALUE2, CONTAINER2&gt;] const& lhs,
    xref:bsl/queue-0a5.adoc[queue&lt;VALUE2, CONTAINER2&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-09b.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE,
    class CONTAINER&gt;
bool
xref:bsl/operator_eq-0aef.adoc[operator&equals;&equals;](
    xref:bsl/queue-0a5.adoc[queue&lt;VALUE, CONTAINER&gt;] const& lhs,
    xref:bsl/queue-0a5.adoc[queue&lt;VALUE, CONTAINER&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-0aef.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:bsl/operator_eq-087.adoc[operator&equals;&equals;](
    xref:bsl/unordered_set-0d2d.adoc[unordered&lowbar;set&lt;KEY2, HASH2, EQUAL2, ALLOCATOR2&gt;] const& lhs,
    xref:bsl/unordered_set-0d2d.adoc[unordered&lowbar;set&lt;KEY2, HASH2, EQUAL2, ALLOCATOR2&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-087.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` iterators refer to the same list element or both are the `end()` iterator of the same list&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class T1,
    class T2&gt;
bool
xref:bsl/operator_eq-0e4.adoc[operator&equals;&equals;](
    xref:bsl/List_Iterator.adoc[List&lowbar;Iterator&lt;T1&gt;] lhs,
    xref:bsl/List_Iterator.adoc[List&lowbar;Iterator&lt;T2&gt;] rhs);
----

[.small]#xref:bsl/operator_eq-0e4.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE,
    class ALLOCATOR&gt;
bool
xref:bsl/operator_eq-0b6.adoc[operator&equals;&equals;](
    xref:bsl/list-054.adoc[list&lt;VALUE, ALLOCATOR&gt;] const& lhs,
    xref:bsl/list-054.adoc[list&lt;VALUE, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-0b6.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified iterators refer to the same node&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class &lowbar;Val,
    class &lowbar;Traits,
    class &lowbar;Traits1,
    class &lowbar;Key,
    class &lowbar;HF,
    class &lowbar;ExK,
    class &lowbar;EqK,
    class &lowbar;All&gt;
bool
xref:bsl/operator_eq-07.adoc[operator&equals;&equals;](
    xref:bsl/_Ht_iterator.adoc[&lowbar;Ht&lowbar;iterator&lt;&lowbar;Val, &lowbar;Traits, &lowbar;Key, &lowbar;HF, &lowbar;ExK, &lowbar;EqK, &lowbar;All&gt;] const& &lowbar;&lowbar;x,
    xref:bsl/_Ht_iterator.adoc[&lowbar;Ht&lowbar;iterator&lt;&lowbar;Val, &lowbar;Traits1, &lowbar;Key, &lowbar;HF, &lowbar;ExK, &lowbar;EqK, &lowbar;All&gt;] const& &lowbar;&lowbar;y);
----

[.small]#xref:bsl/operator_eq-07.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified hash tables contain the same elements&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class &lowbar;Val,
    class &lowbar;Key,
    class &lowbar;HF,
    class &lowbar;ExK,
    class &lowbar;EqK,
    class &lowbar;All&gt;
bool
xref:bsl/operator_eq-0df.adoc[operator&equals;&equals;](
    xref:bsl/hashtable.adoc[hashtable&lt;&lowbar;Val, &lowbar;Key, &lowbar;HF, &lowbar;ExK, &lowbar;EqK, &lowbar;All&gt;] const& &lowbar;&lowbar;hm1,
    xref:bsl/hashtable.adoc[hashtable&lt;&lowbar;Val, &lowbar;Key, &lowbar;HF, &lowbar;ExK, &lowbar;EqK, &lowbar;All&gt;] const& &lowbar;&lowbar;hm2);
----

[.small]#xref:bsl/operator_eq-0df.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified hash sets contain the same elements&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class &lowbar;Value,
    class &lowbar;HashFcn,
    class &lowbar;EqualKey,
    class &lowbar;Alloc&gt;
bool
xref:bsl/operator_eq-017.adoc[operator&equals;&equals;](
    xref:bsl/hash_set.adoc[hash&lowbar;set&lt;&lowbar;Value, &lowbar;HashFcn, &lowbar;EqualKey, &lowbar;Alloc&gt;] const& &lowbar;&lowbar;hm1,
    xref:bsl/hash_set.adoc[hash&lowbar;set&lt;&lowbar;Value, &lowbar;HashFcn, &lowbar;EqualKey, &lowbar;Alloc&gt;] const& &lowbar;&lowbar;hm2);
----

[.small]#xref:bsl/operator_eq-017.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified hash multisets contain the same elements&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class &lowbar;Value,
    class &lowbar;HashFcn,
    class &lowbar;EqualKey,
    class &lowbar;Alloc&gt;
bool
xref:bsl/operator_eq-098.adoc[operator&equals;&equals;](
    xref:bsl/hash_multiset.adoc[hash&lowbar;multiset&lt;&lowbar;Value, &lowbar;HashFcn, &lowbar;EqualKey, &lowbar;Alloc&gt;] const& &lowbar;&lowbar;hm1,
    xref:bsl/hash_multiset.adoc[hash&lowbar;multiset&lt;&lowbar;Value, &lowbar;HashFcn, &lowbar;EqualKey, &lowbar;Alloc&gt;] const& &lowbar;&lowbar;hm2);
----

[.small]#xref:bsl/operator_eq-098.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified lists have the same elements in order&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class &lowbar;Tp,
    class &lowbar;Alloc&gt;
bool
xref:bsl/operator_eq-0a7.adoc[operator&equals;&equals;](
    xref:bsl/slist.adoc[slist&lt;&lowbar;Tp, &lowbar;Alloc&gt;] const& &lowbar;SL1,
    xref:bsl/slist.adoc[slist&lt;&lowbar;Tp, &lowbar;Alloc&gt;] const& &lowbar;SL2);
----

[.small]#xref:bsl/operator_eq-0a7.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified hash maps contain the same elements&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class &lowbar;Key,
    class &lowbar;Tp,
    class &lowbar;HashFcn,
    class &lowbar;EqlKey,
    class &lowbar;Alloc&gt;
bool
xref:bsl/operator_eq-08d.adoc[operator&equals;&equals;](
    xref:bsl/hash_map.adoc[hash&lowbar;map&lt;&lowbar;Key, &lowbar;Tp, &lowbar;HashFcn, &lowbar;EqlKey, &lowbar;Alloc&gt;] const& &lowbar;&lowbar;hm1,
    xref:bsl/hash_map.adoc[hash&lowbar;map&lt;&lowbar;Key, &lowbar;Tp, &lowbar;HashFcn, &lowbar;EqlKey, &lowbar;Alloc&gt;] const& &lowbar;&lowbar;hm2);
----

[.small]#xref:bsl/operator_eq-08d.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified hash multimaps contain the same elements&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class &lowbar;Key,
    class &lowbar;Tp,
    class &lowbar;HashFcn,
    class &lowbar;EqlKey,
    class &lowbar;Alloc&gt;
bool
xref:bsl/operator_eq-0e6.adoc[operator&equals;&equals;](
    xref:bsl/hash_multimap.adoc[hash&lowbar;multimap&lt;&lowbar;Key, &lowbar;Tp, &lowbar;HashFcn, &lowbar;EqlKey, &lowbar;Alloc&gt;] const& &lowbar;&lowbar;hm1,
    xref:bsl/hash_multimap.adoc[hash&lowbar;multimap&lt;&lowbar;Key, &lowbar;Tp, &lowbar;HashFcn, &lowbar;EqlKey, &lowbar;Alloc&gt;] const& &lowbar;&lowbar;hm2);
----

[.small]#xref:bsl/operator_eq-0e6.adoc[_» more&period;&period;&period;_]#

Return whether `lhs` and `rhs` refer to the same stop state&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
&lsqb;&lsqb;nodiscard&rsqb;&rsqb;
bool
xref:bsl/operator_eq-067.adoc[operator&equals;&equals;](
    xref:bsl/stop_source.adoc[stop&lowbar;source] const& lhs,
    xref:bsl/stop_source.adoc[stop&lowbar;source] const& rhs) noexcept;
----

[.small]#xref:bsl/operator_eq-067.adoc[_» more&period;&period;&period;_]#

Return whether `lhs` and `rhs` refer to the same stop state&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
&lsqb;&lsqb;nodiscard&rsqb;&rsqb;
bool
xref:bsl/operator_eq-0c5.adoc[operator&equals;&equals;](
    xref:bsl/stop_token.adoc[stop&lowbar;token] const& lhs,
    xref:bsl/stop_token.adoc[stop&lowbar;token] const& rhs) noexcept;
----

[.small]#xref:bsl/operator_eq-0c5.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY,
    class COMPARATOR,
    class ALLOCATOR&gt;
bool
xref:bsl/operator_eq-0a8.adoc[operator&equals;&equals;](
    xref:bsl/multiset-03.adoc[multiset&lt;KEY, COMPARATOR, ALLOCATOR&gt;] const& lhs,
    xref:bsl/multiset-03.adoc[multiset&lt;KEY, COMPARATOR, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-0a8.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` iterators refer to the same element in the same underlying sequence or both refer to the past&hyphen;the&hyphen;end element&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:bsl/operator_eq-055.adoc[operator&equals;&equals;](
    xref:bsl/vector_UintPtrConversionIterator.adoc[vector&lowbar;UintPtrConversionIterator] const& lhs,
    xref:bsl/vector_UintPtrConversionIterator.adoc[vector&lowbar;UintPtrConversionIterator] const& rhs);
----

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

Return whether the operands have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE&lowbar;TYPE,
    class ALLOCATOR&gt;
bool
xref:bsl/operator_eq-013.adoc[operator&equals;&equals;](
    xref:bsl/vector-00d.adoc[vector&lt;VALUE&lowbar;TYPE, ALLOCATOR&gt;] const& lhs,
    xref:bsl/vector-00d.adoc[vector&lt;VALUE&lowbar;TYPE, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-013.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:bsl/operator_eq-04a.adoc[operator&equals;&equals;](
    xref:bsl/vector-086.adoc[vector] const& lhs,
    xref:bsl/vector-086.adoc[vector] const& rhs);
----

[.small]#xref:bsl/operator_eq-04a.adoc[_» more&period;&period;&period;_]#

Same as the two&hyphen;argument `operator&equals;&equals;` for `basic&lowbar;string`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class CHAR&lowbar;TYPE,
    class CHAR&lowbar;TRAITS,
    class ALLOC&gt;
bool
xref:bsl/operator_eq-052.adoc[operator&equals;&equals;](
    xref:bsl/basic_string-0faf.adoc[basic&lowbar;string&lt;CHAR&lowbar;TYPE, CHAR&lowbar;TRAITS, ALLOC&gt;] const& lhs,
    xref:bsl/basic_string-0faf.adoc[basic&lowbar;string&lt;CHAR&lowbar;TYPE, CHAR&lowbar;TRAITS, ALLOC&gt;] const& rhs) noexcept;
----

[.small]#xref:bsl/operator_eq-052.adoc[_» more&period;&period;&period;_]#

Same as the two&hyphen;argument `operator&equals;&equals;` for mixed `bsl`&sol;`std` strings&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class CHAR&lowbar;TYPE,
    class CHAR&lowbar;TRAITS,
    class ALLOC1,
    class ALLOC2&gt;
bool
xref:bsl/operator_eq-0c0.adoc[operator&equals;&equals;](
    xref:bsl/basic_string-0faf.adoc[bsl::basic&lowbar;string&lt;CHAR&lowbar;TYPE, CHAR&lowbar;TRAITS, ALLOC1&gt;] const& lhs,
    std::basic&lowbar;string&lt;CHAR&lowbar;TYPE, CHAR&lowbar;TRAITS, ALLOC2&gt; const& rhs) noexcept;
----

[.small]#xref:bsl/operator_eq-0c0.adoc[_» more&period;&period;&period;_]#

Return whether two strings have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class CHAR&lowbar;TYPE,
    class CHAR&lowbar;TRAITS,
    class ALLOC&gt;
bool
xref:bsl/operator_eq-02e.adoc[operator&equals;&equals;](
    xref:bsl/basic_string-0faf.adoc[basic&lowbar;string&lt;CHAR&lowbar;TYPE, CHAR&lowbar;TRAITS, ALLOC&gt;] const& lhs,
    CHAR&lowbar;TYPE const* rhs);
----

[.small]#xref:bsl/operator_eq-02e.adoc[_» more&period;&period;&period;_]#

Return whether `lhs` and `rhs` refer to the same object&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:bsl/operator_eq-0cd9.adoc[operator&equals;&equals;](
    xref:bsl/shared_ptr-0a.adoc[shared&lowbar;ptr&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:bsl/shared_ptr-0a.adoc[shared&lowbar;ptr&lt;RHS&lowbar;TYPE&gt;] const& rhs) noexcept;
----

[.small]#xref:bsl/operator_eq-0cd9.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` shared pointer does not refer to an object, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class LHS&lowbar;TYPE&gt;
bool
xref:bsl/operator_eq-0ec.adoc[operator&equals;&equals;](
    xref:bsl/shared_ptr-0a.adoc[shared&lowbar;ptr&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:bsl/nullptr_t-08.adoc[nullptr&lowbar;t] nullPointerLiteral) noexcept;
----

[.small]#xref:bsl/operator_eq-0ec.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY,
    class VALUE,
    class COMPARATOR,
    class ALLOCATOR&gt;
bool
xref:bsl/operator_eq-04b.adoc[operator&equals;&equals;](
    xref:bsl/map-0a7.adoc[map&lt;KEY, VALUE, COMPARATOR, ALLOCATOR&gt;] const& lhs,
    xref:bsl/map-0a7.adoc[map&lt;KEY, VALUE, COMPARATOR, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-04b.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY,
    class VALUE,
    class COMPARATOR,
    class ALLOCATOR&gt;
bool
xref:bsl/operator_eq-03.adoc[operator&equals;&equals;](
    xref:bsl/multimap-0ae.adoc[multimap&lt;KEY, VALUE, COMPARATOR, ALLOCATOR&gt;] const& lhs,
    xref:bsl/multimap-0ae.adoc[multimap&lt;KEY, VALUE, COMPARATOR, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-03.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY,
    class COMPARATOR,
    class ALLOCATOR&gt;
bool
xref:bsl/operator_eq-045.adoc[operator&equals;&equals;](
    xref:bsl/set-0d.adoc[set&lt;KEY, COMPARATOR, ALLOCATOR&gt;] const& lhs,
    xref:bsl/set-0d.adoc[set&lt;KEY, COMPARATOR, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-045.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class T1,
    class T2&gt;
constexpr
bool
xref:bsl/operator_eq-0cf.adoc[operator&equals;&equals;](
    xref:bsl/pair-0b.adoc[pair&lt;T1, T2&gt;] const& lhs,
    xref:bsl/pair-0b.adoc[pair&lt;T1, T2&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-0cf.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `function` is empty&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class PROTOTYPE&gt;
bool
xref:bsl/operator_eq-09d2.adoc[operator&equals;&equals;](
    xref:bsl/function-0a.adoc[function&lt;PROTOTYPE&gt;] const& f,
    xref:bsl/nullptr_t-08.adoc[nullptr&lowbar;t] unused) noexcept;
----

[.small]#xref:bsl/operator_eq-09d2.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `function` is empty&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class PROTOTYPE&gt;
bool
xref:bsl/operator_eq-0ac.adoc[operator&equals;&equals;](
    xref:bsl/nullptr_t-08.adoc[nullptr&lowbar;t] unused,
    xref:bsl/function-0a.adoc[function&lt;PROTOTYPE&gt;] const& f) noexcept;
----

[.small]#xref:bsl/operator_eq-0ac.adoc[_» more&period;&period;&period;_]#

Return whether the operands have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class t&lowbar;LHS&lowbar;TYPE,
    class t&lowbar;RHS&lowbar;TYPE&gt;
constexpr
bool
xref:bsl/operator_eq-097.adoc[operator&equals;&equals;](
    xref:bsl/optional-072.adoc[bsl::optional&lt;t&lowbar;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:bsl/optional-072.adoc[bsl::optional&lt;t&lowbar;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-097.adoc[_» more&period;&period;&period;_]#

Return whether the operands have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class t&lowbar;TYPE&gt;
constexpr
bool
xref:bsl/operator_eq-0db.adoc[operator&equals;&equals;](
    xref:bsl/optional-072.adoc[bsl::optional&lt;t&lowbar;TYPE&gt;] const& value,
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const& nullopt) noexcept;
----

[.small]#xref:bsl/operator_eq-0db.adoc[_» more&period;&period;&period;_]#

Return whether the operands have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class t&lowbar;LHS&lowbar;TYPE,
    class t&lowbar;RHS&lowbar;TYPE&gt;
constexpr
bool
xref:bsl/operator_eq-02a.adoc[operator&equals;&equals;](
    xref:bsl/optional-072.adoc[bsl::optional&lt;t&lowbar;LHS&lowbar;TYPE&gt;] const& lhs,
    t&lowbar;RHS&lowbar;TYPE const& rhs);
----

[.small]#xref:bsl/operator_eq-02a.adoc[_» more&period;&period;&period;_]#

Compare an optional object with a value for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class t&lowbar;LHS&lowbar;TYPE,
    class t&lowbar;RHS&lowbar;TYPE&gt;
constexpr
bool
xref:bsl/operator_eq-0ae7.adoc[operator&equals;&equals;](
    t&lowbar;LHS&lowbar;TYPE const& lhs,
    xref:bsl/optional-072.adoc[bsl::optional&lt;t&lowbar;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-0ae7.adoc[_» more&period;&period;&period;_]#

Return whether the operands have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class t&lowbar;LHS&lowbar;TYPE,
    class t&lowbar;RHS&lowbar;TYPE&gt;
constexpr
bool
xref:bsl/operator_eq-0cd4.adoc[operator&equals;&equals;](
    std::optional&lt;t&lowbar;LHS&lowbar;TYPE&gt; const& lhs,
    xref:bsl/optional-072.adoc[bsl::optional&lt;t&lowbar;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-0cd4.adoc[_» more&period;&period;&period;_]#

Compare a `std&colon;&colon;optional` with a `bsl&colon;&colon;optional` for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class t&lowbar;LHS&lowbar;TYPE,
    class t&lowbar;RHS&lowbar;TYPE&gt;
constexpr
bool
xref:bsl/operator_eq-09de.adoc[operator&equals;&equals;](
    xref:bsl/optional-072.adoc[bsl::optional&lt;t&lowbar;LHS&lowbar;TYPE&gt;] const& lhs,
    std::optional&lt;t&lowbar;RHS&lowbar;TYPE&gt; const& rhs);
----

[.small]#xref:bsl/operator_eq-09de.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:bsl/operator_eq-0a2.adoc[operator&equals;&equals;](
    xref:bsl/unordered_multiset-06c.adoc[unordered&lowbar;multiset&lt;KEY2, HASH2, EQUAL2, ALLOCATOR2&gt;] const& lhs,
    xref:bsl/unordered_multiset-06c.adoc[unordered&lowbar;multiset&lt;KEY2, HASH2, EQUAL2, ALLOCATOR2&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-0a2.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class KEY,
    class HASH,
    class EQUAL,
    class ALLOCATOR&gt;
bool
xref:bsl/operator_eq-094.adoc[operator&equals;&equals;](
    xref:bsl/unordered_multiset-06c.adoc[unordered&lowbar;multiset&lt;KEY, HASH, EQUAL, ALLOCATOR&gt;] const& lhs,
    xref:bsl/unordered_multiset-06c.adoc[unordered&lowbar;multiset&lt;KEY, HASH, EQUAL, ALLOCATOR&gt;] const& rhs);
----

[.small]#xref:bsl/operator_eq-094.adoc[_» more&period;&period;&period;_]#

== Return Value

* `true` if the iterators refer to the same element
* `true` if equal, otherwise `false`
* `true` if the unordered multimaps compare equal
* `true` if the deques compare equal
* `true` if the stacks have the same value, `false` otherwise
* `true` if `lhs` and `rhs` are equal
* `true` if the queues have the same value, otherwise `false`
* `true` if the lists compare equal
* `true` if the iterators refer to the same node
* `true` if the hash tables contain the same elements
* `true` if the hash sets contain the same elements
* `true` if the hash multisets contain the same elements
* `true` if the lists are equal, and `false` otherwise
* `true` if the hash maps contain the same elements
* `true` if the hash multimaps contain the same elements
* `true` if both refer to the same stop state (or neither)
* `true` if `lhs` and `rhs` compare equal, and `false` otherwise
* `true` if the operands compare equal, and `false` otherwise
* `true` if the vectors have the same value, and `false` otherwise
* `true` if the vectors have the same value, and `false` otherwise
* `true` if the strings compare equal
* `true` if `lhs` and `rhs` refer to the same object
* `true` if `lhs` does not refer to an object
* `true` if the maps compare equal
* `true` if the multimaps compare equal
* `true` if the sets compare equal
* `true` if the pairs have the same value, and `false` otherwise
* `true` if `f` is empty, and `false` otherwise
* `true` if `lhs` and `rhs` have the same value, and `false` otherwise
* `true` if `value` is disengaged, and `false` otherwise

== Parameters

[cols="1,4"]
|===
| Name| Description
| *lhs*
| first iterator to compare
| *rhs*
| second iterator to compare
| *&lowbar;&lowbar;x*
| left&hyphen;hand iterator
| *&lowbar;&lowbar;y*
| right&hyphen;hand iterator
| *&lowbar;&lowbar;hm1*
| first hash table
| *&lowbar;&lowbar;hm2*
| second hash table
| *&lowbar;SL1*
| first list compared
| *&lowbar;SL2*
| second list compared
| *nullPointerLiteral*
| null&hyphen;pointer literal (unused&semi; selects this overload)
| *f*
| function object to compare with null
| *unused*
| null pointer literal
| *value*
| value compared with or used to initialize the optional
| *nullopt*
| disengaged&hyphen;optional tag&semi; value is unused
|===


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