public member function

std::map::value_comp

<map>
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)