[#bsl-operator_eq-08e] = xref:bsl.adoc[bsl]::operator== :relfileprefix: ../ :mrdocs: Equality operators == Synopses Declared in `<bslstl_deque.h>` 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:bsl/operator_eq-0da.adoc[operator==]( xref:bsl/List_Iterator.adoc[List_Iterator<T1>], xref:bsl/List_Iterator.adoc[List_Iterator<T2>]); ---- [.small]#xref:bsl/operator_eq-0da.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:bsl/operator_eq-087.adoc[operator==]( xref:bsl/unordered_set-0d2d.adoc[unordered_set<KEY2, HASH2, EQUAL2, ALLOCATOR2>] const&, xref:bsl/unordered_set-0d2d.adoc[unordered_set<KEY2, HASH2, EQUAL2, ALLOCATOR2>] const&); ---- [.small]#xref:bsl/operator_eq-087.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `unordered_set` objects have the same value if they have the same number of value‐elements, and for each value‐element that is contained in `lhs` there is a value‐element contained in `rhs` having the same value, and vice‐versa. Note that this method requires that the (template parameter) type `KEY` be `equality‐comparable` (see {Requirements on `KEY`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class KEY, class HASH, class EQUAL, class ALLOCATOR> bool xref:bsl/operator_eq-0b3.adoc[operator==]( xref:bsl/unordered_set-0d2d.adoc[unordered_set<KEY, HASH, EQUAL, ALLOCATOR>] const& lhs, xref:bsl/unordered_set-0d2d.adoc[unordered_set<KEY, HASH, EQUAL, ALLOCATOR>] const& rhs); ---- [.small]#xref:bsl/operator_eq-0b3.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:bsl/operator_eq-0cb.adoc[operator==]( xref:bsl/unordered_map-02b.adoc[unordered_map<KEY2, VALUE2, HASH2, EQUAL2, ALLOCATOR2>] const&, xref:bsl/unordered_map-02b.adoc[unordered_map<KEY2, VALUE2, HASH2, EQUAL2, ALLOCATOR2>] const&); ---- [.small]#xref:bsl/operator_eq-0cb.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `unordered_map` objects have the same value if they have the same number of key‐value pairs, and for each key‐value pair that is contained in `lhs` there is a key‐value pair contained in `rhs` having the same value, and vice versa. Note that this method requires that the (template parameter) types `KEY` and `VALUE` both be `equality‐comparable` (see {Requirements on `value_type`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class KEY, class VALUE, class HASH, class EQUAL, class ALLOCATOR> bool xref:bsl/operator_eq-024.adoc[operator==]( xref:bsl/unordered_map-02b.adoc[unordered_map<KEY, VALUE, HASH, EQUAL, ALLOCATOR>] const& lhs, xref:bsl/unordered_map-02b.adoc[unordered_map<KEY, VALUE, HASH, EQUAL, ALLOCATOR>] const& rhs); ---- [.small]#xref:bsl/operator_eq-024.adoc[_» more..._]# Same as the related overload above for `operator==`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:bsl/operator_eq-068.adoc[operator==]( xref:bsl/unordered_multimap-0b0.adoc[unordered_multimap<KEY2, VALUE2, HASH2, EQUAL2, ALLOCATOR2>] const&, xref:bsl/unordered_multimap-0b0.adoc[unordered_multimap<KEY2, VALUE2, HASH2, EQUAL2, ALLOCATOR2>] const&); ---- [.small]#xref:bsl/operator_eq-068.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `unordered_multimap` objects have the same value if they have the same number of key‐value pairs, and each key‐value pair that is contained in one of the objects is also contained in the other object. This method requires that the (template parameter) types `KEY` and `VALUE` both be `equality‐comparable` (see {Requirements on `KEY` and `VALUE`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class KEY, class VALUE, class HASH, class EQUAL, class ALLOCATOR> bool xref:bsl/operator_eq-08a.adoc[operator==]( xref:bsl/unordered_multimap-0b0.adoc[unordered_multimap<KEY, VALUE, HASH, EQUAL, ALLOCATOR>] const& lhs, xref:bsl/unordered_multimap-0b0.adoc[unordered_multimap<KEY, VALUE, HASH, EQUAL, ALLOCATOR>] const& rhs); ---- [.small]#xref:bsl/operator_eq-08a.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `deque` objects `lhs` and `rhs` have the same value if they have the same number of elements, and each element in the ordered sequence of elements of `lhs` has the same value as the corresponding element in the ordered sequence of elements of `rhs`. This method requires that the (template parameter) type `VALUE_TYPE` be `equality‐comparable` (see {Requirements on `VALUE_TYPE`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class VALUE_TYPE, class ALLOCATOR> bool xref:bsl/operator_eq-0ce.adoc[operator==]( xref:bsl/deque-0c.adoc[deque<VALUE_TYPE, ALLOCATOR>] const& lhs, xref:bsl/deque-0c.adoc[deque<VALUE_TYPE, ALLOCATOR>] const& rhs); ---- [.small]#xref:bsl/operator_eq-0ce.adoc[_» more..._]# Same as the related overload above for `operator==`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:bsl/operator_eq-00.adoc[operator==]( xref:bsl/stack-05.adoc[stack<VAL, CONT>] const&, xref:bsl/stack-05.adoc[stack<VAL, CONT>] const&); ---- [.small]#xref:bsl/operator_eq-00.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `stack` objects `lhs` and `rhs` have the same value if they have the same number of elements, and each element in the ordered sequence of elements of `lhs` has the same value as the corresponding element in the ordered sequence of elements of `rhs`. This method requires that the (template parameter) type `VALUE` be `equality‐comparable` (see {Requirements on `VALUE`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class VALUE, class CONTAINER> bool xref:bsl/operator_eq-0e3.adoc[operator==]( xref:bsl/stack-05.adoc[stack<VALUE, CONTAINER>] const& lhs, xref:bsl/stack-05.adoc[stack<VALUE, CONTAINER>] const& rhs); ---- [.small]#xref:bsl/operator_eq-0e3.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` are both valueless by exception or if they have the same active alternative and their contained values compare equal; otherwise, return `false`. All alternatives shall support `operator==`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class t_HEAD, class... t_TAIL> bool xref:bsl/operator_eq-058.adoc[operator==]( xref:bsl/variant.adoc[variant<t_HEAD, t_TAIL...>] const& lhs, xref:bsl/variant.adoc[variant<t_HEAD, t_TAIL...>] const& rhs); ---- [.small]#xref:bsl/operator_eq-058.adoc[_» more..._]# Return whether the specified queues have the same value; see the non‐member `operator==` in the `bsl` namespace. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:bsl/operator_eq-09b.adoc[operator==]( xref:bsl/queue-0a5.adoc[queue<VALUE2, CONTAINER2>] const&, xref:bsl/queue-0a5.adoc[queue<VALUE2, CONTAINER2>] const&); ---- [.small]#xref:bsl/operator_eq-09b.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `queue` objects `lhs` and `rhs` have the same value if they have the same number of elements, and each element in the ordered sequence of elements of `lhs` has the same value as the corresponding element in the ordered sequence of elements of `rhs`. This method requires that the (template parameter) type `VALUE` be `equality‐comparable` (see {Requirements on `VALUE`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class VALUE, class CONTAINER> bool xref:bsl/operator_eq-0aef.adoc[operator==]( xref:bsl/queue-0a5.adoc[queue<VALUE, CONTAINER>] const& lhs, xref:bsl/queue-0a5.adoc[queue<VALUE, CONTAINER>] const& rhs); ---- [.small]#xref:bsl/operator_eq-0aef.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `unordered_multiset` objects have the same value if they have the same number of value elements, and for each value‐element that is contained in `lhs` there is a value‐element contained in `rhs` having the same value, and vice‐versa. Note that this method requires that the (template parameter) type `KEY` be `equality‐comparable` (see {Requirements on `KEY`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class KEY, class HASH, class EQUAL, class ALLOCATOR> bool xref:bsl/operator_eq-094.adoc[operator==]( xref:bsl/unordered_multiset-06c.adoc[unordered_multiset<KEY, HASH, EQUAL, ALLOCATOR>] const& lhs, xref:bsl/unordered_multiset-06c.adoc[unordered_multiset<KEY, HASH, EQUAL, ALLOCATOR>] const& rhs); ---- [.small]#xref:bsl/operator_eq-094.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class T1, class T2> bool xref:bsl/operator_eq-0e4.adoc[operator==]( xref:bsl/List_Iterator.adoc[List_Iterator<T1>] lhs, xref:bsl/List_Iterator.adoc[List_Iterator<T2>] rhs); ---- [.small]#xref:bsl/operator_eq-0e4.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `list` objects `lhs` and `rhs` have the same value if they have the same number of elements, and each element in the ordered sequence of elements of `lhs` has the same value as the corresponding element in the ordered sequence of elements of `rhs`. This method requires that the (template parameter) type `VALUE` be `equality‐comparable` (see {Requirements on `VALUE`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class VALUE, class ALLOCATOR> bool xref:bsl/operator_eq-0b6.adoc[operator==]( xref:bsl/list-054.adoc[list<VALUE, ALLOCATOR>] const& lhs, xref:bsl/list-054.adoc[list<VALUE, ALLOCATOR>] const& rhs); ---- [.small]#xref:bsl/operator_eq-0b6.adoc[_» more..._]# Return `true` if the specified iterators refer to the same node. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class _Val, class _Traits, class _Traits1, class _Key, class _HF, class _ExK, class _EqK, class _All> bool xref:bsl/operator_eq-07.adoc[operator==]( xref:bsl/_Ht_iterator.adoc[_Ht_iterator<_Val, _Traits, _Key, _HF, _ExK, _EqK, _All>] const& __x, xref:bsl/_Ht_iterator.adoc[_Ht_iterator<_Val, _Traits1, _Key, _HF, _ExK, _EqK, _All>] const& __y); ---- [.small]#xref:bsl/operator_eq-07.adoc[_» more..._]# Return `true` if the specified hash tables contain the same elements. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class _Val, class _Key, class _HF, class _ExK, class _EqK, class _All> bool xref:bsl/operator_eq-0df.adoc[operator==]( xref:bsl/hashtable.adoc[hashtable<_Val, _Key, _HF, _ExK, _EqK, _All>] const& __hm1, xref:bsl/hashtable.adoc[hashtable<_Val, _Key, _HF, _ExK, _EqK, _All>] const& __hm2); ---- [.small]#xref:bsl/operator_eq-0df.adoc[_» more..._]# Return `true` if the specified hash sets contain the same elements. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class _Value, class _HashFcn, class _EqualKey, class _Alloc> bool xref:bsl/operator_eq-017.adoc[operator==]( xref:bsl/hash_set.adoc[hash_set<_Value, _HashFcn, _EqualKey, _Alloc>] const& __hm1, xref:bsl/hash_set.adoc[hash_set<_Value, _HashFcn, _EqualKey, _Alloc>] const& __hm2); ---- [.small]#xref:bsl/operator_eq-017.adoc[_» more..._]# Return `true` if the specified hash multisets contain the same elements. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class _Value, class _HashFcn, class _EqualKey, class _Alloc> bool xref:bsl/operator_eq-098.adoc[operator==]( xref:bsl/hash_multiset.adoc[hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>] const& __hm1, xref:bsl/hash_multiset.adoc[hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>] const& __hm2); ---- [.small]#xref:bsl/operator_eq-098.adoc[_» more..._]# Return `true` if the specified lists have the same elements in order. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class _Tp, class _Alloc> bool xref:bsl/operator_eq-0a7.adoc[operator==]( xref:bsl/slist.adoc[slist<_Tp, _Alloc>] const& _SL1, xref:bsl/slist.adoc[slist<_Tp, _Alloc>] const& _SL2); ---- [.small]#xref:bsl/operator_eq-0a7.adoc[_» more..._]# Return `true` if the specified hash maps contain the same elements. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc> bool xref:bsl/operator_eq-08d.adoc[operator==]( xref:bsl/hash_map.adoc[hash_map<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>] const& __hm1, xref:bsl/hash_map.adoc[hash_map<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>] const& __hm2); ---- [.small]#xref:bsl/operator_eq-08d.adoc[_» more..._]# Return `true` if the specified hash multimaps contain the same elements. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc> bool xref:bsl/operator_eq-0e6.adoc[operator==]( xref:bsl/hash_multimap.adoc[hash_multimap<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>] const& __hm1, xref:bsl/hash_multimap.adoc[hash_multimap<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>] const& __hm2); ---- [.small]#xref:bsl/operator_eq-0e6.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` refer to the same stop state, or if neither refers to a stop state; `false` otherwise. Implementation note: this function is required by the standard to be a hidden friend ([hidden.friends], [stopsource.general]). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- [[nodiscard]] bool xref:bsl/operator_eq-067.adoc[operator==]( xref:bsl/stop_source.adoc[stop_source] const& lhs, xref:bsl/stop_source.adoc[stop_source] const& rhs) noexcept; ---- [.small]#xref:bsl/operator_eq-067.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` refer to the same stop state, or if neither refers to a stop state; `false` otherwise. Implementation note: this function is required by the standard to be a hidden friend ([hidden.friends], [stoptoken.general]). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- [[nodiscard]] bool xref:bsl/operator_eq-0c5.adoc[operator==]( xref:bsl/stop_token.adoc[stop_token] const& lhs, xref:bsl/stop_token.adoc[stop_token] const& rhs) noexcept; ---- [.small]#xref:bsl/operator_eq-0c5.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `multimap` objects `lhs` and `rhs` have the same value if they have the same number of key‐value pairs, and each element in the ordered sequence of key‐value pairs of `lhs` has the same value as the corresponding element in the ordered sequence of key‐value pairs of `rhs`. This method requires that the (template parameter) types `KEY` and `VALUE` both be `equality‐comparable` (see {Requirements on `KEY` and `VALUE`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class KEY, class VALUE, class COMPARATOR, class ALLOCATOR> bool xref:bsl/operator_eq-03.adoc[operator==]( xref:bsl/multimap-0ae.adoc[multimap<KEY, VALUE, COMPARATOR, ALLOCATOR>] const& lhs, xref:bsl/multimap-0ae.adoc[multimap<KEY, VALUE, COMPARATOR, ALLOCATOR>] const& rhs); ---- [.small]#xref:bsl/operator_eq-03.adoc[_» more..._]# 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‐the‐end element of the same sequence, and `false` otherwise. The behavior is undefined if `lhs` and `rhs` do not iterate over the same sequence. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:bsl/operator_eq-055.adoc[operator==]( xref:bsl/vector_UintPtrConversionIterator.adoc[vector_UintPtrConversionIterator] const& lhs, xref:bsl/vector_UintPtrConversionIterator.adoc[vector_UintPtrConversionIterator] const& rhs); ---- [.small]#xref:bsl/operator_eq-055.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `vector` objects `lhs` and `rhs` have the same value if they have the same number of elements, and each element in the ordered sequence of elements of `lhs` has the same value as the corresponding element in the ordered sequence of elements of `rhs`. This method requires that the (template parameter) type `VALUE_TYPE` be `equality‐comparable` (see {Requirements on `VALUE_TYPE`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class VALUE_TYPE, class ALLOCATOR> bool xref:bsl/operator_eq-013.adoc[operator==]( xref:bsl/vector-00d.adoc[vector<VALUE_TYPE, ALLOCATOR>] const& lhs, xref:bsl/vector-00d.adoc[vector<VALUE_TYPE, ALLOCATOR>] const& rhs); ---- [.small]#xref:bsl/operator_eq-013.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` vectors have the same value, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:bsl/operator_eq-04a.adoc[operator==]( xref:bsl/vector-086.adoc[vector] const& lhs, xref:bsl/vector-086.adoc[vector] const& rhs); ---- [.small]#xref:bsl/operator_eq-04a.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` vectors have the same value, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:bsl/operator_eq-0eb.adoc[operator==]( xref:bsl/vector-00d.adoc[vector<void*>] const& lhs, xref:bsl/vector-00d.adoc[vector<void*>] const& rhs); ---- [.small]#xref:bsl/operator_eq-0eb.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` vectors have the same value, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:bsl/operator_eq-081.adoc[operator==]( xref:bsl/vector-00d.adoc[vector<char const*>] const& lhs, xref:bsl/vector-00d.adoc[vector<char const*>] const& rhs); ---- [.small]#xref:bsl/operator_eq-081.adoc[_» more..._]# Same as the two‐argument `operator==` for `basic_string`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class CHAR_TYPE, class CHAR_TRAITS, class ALLOC> bool xref:bsl/operator_eq-052.adoc[operator==]( xref:bsl/basic_string-0faf.adoc[basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOC>] const& lhs, xref:bsl/basic_string-0faf.adoc[basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOC>] const& rhs) noexcept; ---- [.small]#xref:bsl/operator_eq-052.adoc[_» more..._]# Same as the two‐argument `operator==` for mixed `bsl`/`std` strings. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class CHAR_TYPE, class CHAR_TRAITS, class ALLOC1, class ALLOC2> bool xref:bsl/operator_eq-0c0.adoc[operator==]( xref:bsl/basic_string-0faf.adoc[bsl::basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOC1>] const& lhs, std::basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOC2> const& rhs) noexcept; ---- [.small]#xref:bsl/operator_eq-0c0.adoc[_» more..._]# Return `true` if the specified `lhs` string has the same value as the specified `rhs` string, and `false` otherwise. Two strings have the same value if they have the same length, and the characters at each respective position have the same value according to `CHAR_TRAITS::eq`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class CHAR_TYPE, class CHAR_TRAITS, class ALLOC> bool xref:bsl/operator_eq-02e.adoc[operator==]( xref:bsl/basic_string-0faf.adoc[basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOC>] const& lhs, CHAR_TYPE const* rhs); ---- [.small]#xref:bsl/operator_eq-02e.adoc[_» more..._]# Return `true` if the specified `lhs` shared pointer refers to the same object (if any) as that referred to by the specified `rhs` shared pointer (if any), and `false` otherwise; a compiler diagnostic will be emitted indicating the error unless a (raw) pointer to `LHS_TYPE` can be compared to a (raw) pointer to `RHS_TYPE`. Note that two shared pointers that compare equal do not necessarily manage the same object due to aliasing. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:bsl/operator_eq-0cd9.adoc[operator==]( xref:bsl/shared_ptr-0a.adoc[shared_ptr<LHS_TYPE>] const& lhs, xref:bsl/shared_ptr-0a.adoc[shared_ptr<RHS_TYPE>] const& rhs) noexcept; ---- [.small]#xref:bsl/operator_eq-0cd9.adoc[_» more..._]# Return `true` if the specified `lhs` shared pointer does not refer to an object, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class LHS_TYPE> bool xref:bsl/operator_eq-0ec.adoc[operator==]( xref:bsl/shared_ptr-0a.adoc[shared_ptr<LHS_TYPE>] const& lhs, xref:bsl/nullptr_t-08.adoc[nullptr_t]) noexcept; ---- [.small]#xref:bsl/operator_eq-0ec.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `map` objects `lhs` and `rhs` have the same value if they have the same number of key‐value pairs, and each element in the ordered sequence of key‐value pairs of `lhs` has the same value as the corresponding element in the ordered sequence of key‐value pairs of `rhs`. This method requires that the (template parameter) types `KEY` and `VALUE` both be `equality‐comparable` (see {Requirements on `KEY` and `VALUE`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class KEY, class VALUE, class COMPARATOR, class ALLOCATOR> bool xref:bsl/operator_eq-04b.adoc[operator==]( xref:bsl/map-0a7.adoc[map<KEY, VALUE, COMPARATOR, ALLOCATOR>] const& lhs, xref:bsl/map-0a7.adoc[map<KEY, VALUE, COMPARATOR, ALLOCATOR>] const& rhs); ---- [.small]#xref:bsl/operator_eq-04b.adoc[_» more..._]# Return true if the specified `lhs` and `rhs` pair objects have the same value and false otherwise. `lhs` has the same value as `rhs` if `lhs.first == rhs.first` and `lhs.second == rhs.second`. A call to this operator will not compile unless both `T1` and `T2` supply `operator==`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class T1, class T2> constexpr bool xref:bsl/operator_eq-0cf.adoc[operator==]( xref:bsl/pair-0b.adoc[pair<T1, T2>] const& lhs, xref:bsl/pair-0b.adoc[pair<T1, T2>] const& rhs); ---- [.small]#xref:bsl/operator_eq-0cf.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `set` objects `lhs` and `rhs` have the same value if they have the same number of keys, and each element in the ordered sequence of keys of `lhs` has the same value as the corresponding element in the ordered sequence of keys of `rhs`. This method requires that the (template parameter) type `KEY` be `equality‐comparable` (see {Requirements on `KEY`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class KEY, class COMPARATOR, class ALLOCATOR> bool xref:bsl/operator_eq-045.adoc[operator==]( xref:bsl/set-0d.adoc[set<KEY, COMPARATOR, ALLOCATOR>] const& lhs, xref:bsl/set-0d.adoc[set<KEY, COMPARATOR, ALLOCATOR>] const& rhs); ---- [.small]#xref:bsl/operator_eq-045.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. Two `multiset` objects `lhs` and `rhs` have the same value if they have the same number of keys, and each element in the ordered sequence of keys of `lhs` has the same value as the corresponding element in the ordered sequence of keys of `rhs`. This method requires that the (template parameter) type `KEY` be `equality‐comparable` (see {Requirements on `KEY`}). [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class KEY, class COMPARATOR, class ALLOCATOR> bool xref:bsl/operator_eq-0a8.adoc[operator==]( xref:bsl/multiset-03.adoc[multiset<KEY, COMPARATOR, ALLOCATOR>] const& lhs, xref:bsl/multiset-03.adoc[multiset<KEY, COMPARATOR, ALLOCATOR>] const& rhs); ---- [.small]#xref:bsl/operator_eq-0a8.adoc[_» more..._]# Return true if the specified `function` argument is empty, otherwise return false. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class PROTOTYPE> bool xref:bsl/operator_eq-09d2.adoc[operator==]( xref:bsl/function-0a.adoc[function<PROTOTYPE>] const& f, xref:bsl/nullptr_t-08.adoc[nullptr_t]) noexcept; ---- [.small]#xref:bsl/operator_eq-09d2.adoc[_» more..._]# Return true if the `function` argument is empty, otherwise return false. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class PROTOTYPE> bool xref:bsl/operator_eq-0ac.adoc[operator==]( xref:bsl/nullptr_t-08.adoc[nullptr_t], xref:bsl/function-0a.adoc[function<PROTOTYPE>] const& f) noexcept; ---- [.small]#xref:bsl/operator_eq-0ac.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` `optional` objects have the same value, and `false` otherwise. Two `optional` objects have the same value if both are disengaged, or if both are engaged and the values of their underlying objects compare equal. This function can be called in constant expressions only if neither `t_LHS_TYPE` nor `t_RHS_TYPE` is allocator‐aware. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class t_LHS_TYPE, class t_RHS_TYPE> constexpr bool xref:bsl/operator_eq-097.adoc[operator==]( xref:bsl/optional-072.adoc[bsl::optional<t_LHS_TYPE>] const& lhs, xref:bsl/optional-072.adoc[bsl::optional<t_RHS_TYPE>] const& rhs); ---- [.small]#xref:bsl/operator_eq-097.adoc[_» more..._]# Return `true` if the specified `value` is disengaged, and `false` otherwise. This function can be called in constant expressions only if `t_TYPE` is not allocator‐aware. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class t_TYPE> constexpr bool xref:bsl/operator_eq-0db.adoc[operator==]( xref:bsl/optional-072.adoc[bsl::optional<t_TYPE>] const& value, xref:bsl/nullopt_t.adoc[bsl::nullopt_t] const&) noexcept; ---- [.small]#xref:bsl/operator_eq-0db.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. An `optional` object and a value of some type have the same value if the optional object is engaged and its underlying value compares equal to the other value. These functions can be called in constant expressions only if the `optional`'s value type is not allocator‐aware. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class t_LHS_TYPE, class t_RHS_TYPE> constexpr bool xref:bsl/operator_eq-02a.adoc[operator==]( xref:bsl/optional-072.adoc[bsl::optional<t_LHS_TYPE>] const& lhs, t_RHS_TYPE const& rhs); ---- [.small]#xref:bsl/operator_eq-02a.adoc[_» more..._]# Compare an optional object with a value for equality. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class t_LHS_TYPE, class t_RHS_TYPE> constexpr bool xref:bsl/operator_eq-0ae7.adoc[operator==]( t_LHS_TYPE const& lhs, xref:bsl/optional-072.adoc[bsl::optional<t_RHS_TYPE>] const& rhs); ---- [.small]#xref:bsl/operator_eq-0ae7.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` optional objects have the same value, and `false` otherwise. Two optional objects have the same value if both are disengaged, or if both are engaged and the values of their underlying objects compare equal. Note that this function will fail to compile if `t_LHS_TYPE` and `t_RHS_TYPE` are not compatible. These functions can be called in constant expressions only if the `bsl::optional`'s value type is not allocator‐aware. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class t_LHS_TYPE, class t_RHS_TYPE> constexpr bool xref:bsl/operator_eq-0cd4.adoc[operator==]( std::optional<t_LHS_TYPE> const& lhs, xref:bsl/optional-072.adoc[bsl::optional<t_RHS_TYPE>] const& rhs); ---- [.small]#xref:bsl/operator_eq-0cd4.adoc[_» more..._]# Compare a `std::optional` with a `bsl::optional` for equality. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class t_LHS_TYPE, class t_RHS_TYPE> constexpr bool xref:bsl/operator_eq-09de.adoc[operator==]( xref:bsl/optional-072.adoc[bsl::optional<t_LHS_TYPE>] const& lhs, std::optional<t_RHS_TYPE> const& rhs); ---- [.small]#xref:bsl/operator_eq-09de.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:bsl/operator_eq-0a2.adoc[operator==]( xref:bsl/unordered_multiset-06c.adoc[unordered_multiset<KEY2, HASH2, EQUAL2, ALLOCATOR2>] const&, xref:bsl/unordered_multiset-06c.adoc[unordered_multiset<KEY2, HASH2, EQUAL2, ALLOCATOR2>] const&); ---- [.small]#xref:bsl/operator_eq-0a2.adoc[_» more..._]# [.small]#Created with https://www.mrdocs.com[MrDocs]#