map::value_comp


public member function
value_compare value_comp ( ) const;

Return value comparison object

Returns a comparison object that can be used to compare two element values (pairs) to get whether the key of the first goes before the second.

The mapped value, although part of the pair, is not taken into consideration in this comparison - only the key value.

The comparison object returned is an object of the member type map::value_compare, which is a nested class that uses the Compare class from the map template class (the third template parameter) to generate the appropriate comparison class:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
template <class Key, class T, class Compare, class Allocator>
class map<Key,T,Compare,Allocator>::value_compare
  : public binary_function<value_type,value_type,bool>
{
  friend class map;
protected:
  Compare comp;
  value_compare (Compare c) : comp(c) {}
public:
  bool operator() (const value_type& x, const value_type& y) const
  {
    return comp(x.first, y.first);
  }
}


The public member of this comparison class returns true if the key of the first argument is considered to go before that of the second, according to the strict weak ordering specified by the comparison object on map construction, and false otherwise.

Notice that value_compare has no public constructor, therefore no objects can be directly created from this nested class outside map members.

Parameters

none

Return value

The value comparison object.
map::value_compare is a member type defined as described above.

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
// map::value_comp
#include <iostream>
#include <map>
using namespace std;

int main ()
{
  map<char,int> mymap;
  map<char,int>::iterator it;
  pair<char,int> highest;

  mymap['x']=1001;
  mymap['y']=2002;
  mymap['z']=3003;

  cout << "mymap contains:\n";

  highest=*mymap.rbegin();          // last element

  it=mymap.begin();
  do {
    cout << (*it).first << " => " << (*it).second << endl;
  } while ( mymap.value_comp()(*it++, highest) );

  return 0;
}


Output:
mymap contains:
x => 1001
y => 2002
z => 3003


Complexity

Constant.

See also

map::key_comp Return key comparison object (public member function)
map::find Get iterator to element (public member function)
map::count Count elements with a specific key (public member function)
map::lower_bound Return iterator to lower bound (public member function)
map::upper_bound Return iterator to upper bound (public member function)