C++

参考

<set>

multiset

函数
<set>

std::relational operators (multiset)

(1)
template <class T, class Compare, class Allocator>  bool operator== ( const multiset<T,Compare,Allocator>& lhs,                    const multiset<T,Compare,Allocator>& rhs );
(2)
template <class T, class Compare, class Allocator>  bool operator!= ( const multiset<T,Compare,Allocator>& lhs,                    const multiset<T,Compare,Allocator>& rhs );
(3)
template <class T, class Compare, class Allocator>  bool operator<  ( const multiset<T,Compare,Allocator>& lhs,                    const multiset<T,Compare,Allocator>& rhs );
(4)
template <class T, class Compare, class Allocator>  bool operator<= ( const multiset<T,Compare,Allocator>& lhs,                    const multiset<T,Compare,Allocator>& rhs );
(5)
template <class T, class Compare, class Allocator>  bool operator>  ( const multiset<T,Compare,Allocator>& lhs,                    const multiset<T,Compare,Allocator>& rhs );
(6)
template <class T, class Compare, class Allocator>  bool operator>= ( const multiset<T,Compare,Allocator>& lhs,                    const multiset<T,Compare,Allocator>& rhs );
Relational operators for multiset
Performs the appropriate comparison operation between the multiset containers lhs and rhs.

The equality comparison (operator==) is performed by first comparing sizes, and if they match, the elements are compared sequentially using operator==, stopping at the first mismatch (as if using algorithm equal).

The less-than comparison (operator<) behaves as if using algorithm lexicographical_compare, which compares the elements sequentially using operator< in a reciprocal manner (i.e., checking both a<b and b<a) and stopping at the first occurrence.

The other operations also use the operators == and < internally to compare the elements, behaving as if the following equivalent operations were performed
operationequivalent operation
a!=b!(a==b)
a>bb<a
a<=b!(b<a)
a>=b!(a<b)

Notice that none of these operations take into consideration the internal comparison object of neither container.

These operators are overloaded in header <set>.

参数

lhs, rhs
multiset containers (to the left- and right-hand side of the operator, respectively), having both the same template parameters (T, Compare和Alloc).

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
// multiset comparisons
#include <iostream>
#include <set>

int main ()
{
  std::multiset<int> foo,bar;
  foo.insert(10);
  bar.insert(20);
  bar.insert(20);
  foo.insert(30);

  // foo ({10,30}) vs bar ({20,20}):
  if (foo==bar) std::cout << "foo and bar are equal\n";
  if (foo!=bar) std::cout << "foo and bar are not equal\n";
  if (foo< bar) std::cout << "foo is less than bar\n";
  if (foo> bar) std::cout << "foo is greater than bar\n";
  if (foo<=bar) std::cout << "foo is less than or equal to bar\n";
  if (foo>=bar) std::cout << "foo is greater than or equal to bar\n";

  return 0;
}

输出
foo and bar are not equal
foo is less than bar
foo is less than or equal to bar


返回值

true如果条件成立，则为 true，并且false否则为 false。

复杂度

Up to linear in the size of lhs and rhs.
For (1) and (2), constant if the sizes of lhs and rhs differ, and up to linear in that size (equality comparisons) otherwise.
For the others, up to linear in the smaller size (each representing two comparisons with operator<).

迭代器有效性

没有变化。

数据竞争

Both containers, lhs and rhs, are accessed.
Concurrently accessing the elements of unmodified set objects is always safe (their elements are immutable).

异常安全

If the type of the elements supports the appropriate operation with no-throw guarantee, the function never throws exceptions (no-throw guarantee).
In any case, the function cannot modify its arguments.

另见

multiset::value_comp
返回比较对象 （公开成员函数）
multiset::operator=
复制容器内容 （公开成员函数）
multiset::swap
交换内容 (公开成员函数)