function template
<vector>
std::relational operators (vector)
| (1) | template <class T, class Alloc>
bool operator== (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);
|
|---|
| (2) | template <class T, class Alloc>
bool operator!= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);
|
|---|
| (3) | template <class T, class Alloc>
bool operator< (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);
|
|---|
| (4) | template <class T, class Alloc>
bool operator<= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);
|
|---|
| (5) | template <class T, class Alloc>
bool operator> (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs);
|
|---|
| (6) | template <class T, class Alloc>
bool operator>= (const vector<T,Alloc>& lhs, const vector<T,Alloc>& rhs); |
|---|
Relational operators for vector
Performs the appropriate comparison operation between the vector 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:
| operation | equivalent operation |
|---|
a!=b | !(a==b) |
a>b | b<a |
a<=b | !(b<a) |
a>=b | !(a<b) |
These operators are overloaded in header <vector>.
Parameters
- lhs, rhs
- vector containers (to the left- and right-hand side of the operator, respectively), having both the same template parameters (T and Alloc).
Return Value
true if the condition holds, and false otherwise.
Example
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
// vector comparisons
#include <iostream>
#include <vector>
int main ()
{
std::vector<int> foo (3,100); // three ints with a value of 100
std::vector<int> bar (2,200); // two ints with a value of 200
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;
}
| |
Output:
foo and bar are not equal
foo is less than bar
foo is less than or equal to bar
|
Complexity
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<).
Iterator validity
No changes.
Data races
Both containers, lhs and rhs, are accessed.
Up to all of their contained elements may be accessed.
In any case, the function cannot modify its arguments (const-qualified).
Exception safety
If the type of the elements supports the appropriate operation with no-throw guarantee, the function never throws exceptions (no-throw guarantee).