Previous fileTop of DocumentContentsIndex pageNext file
Apache C++ Standard Library Reference Guide

multimap

Library:  Containers


Does not inherit

Local Index

Members

Non-Members

Summary

An associative container that gives access to non-key values using keys. multimap keys are not required to be unique. A multimap supports bidirectional iterators.

Synopsis

#include <map>

namespace std {
  template <class Key, class T, class Compare = less<Key>,
            class Allocator = allocator<pair<const Key, T> > >
  class multimap;
}

Description

multimap gives fast access to stored values of type T that are indexed by keys of type Key. The default operation for key comparison is the < operator. Unlike map, multimap allows insertion of duplicate keys.

multimap uses bidirectional iterators that point to an instance of pair<const Key x, T y> where x is the key and y is the stored value associated with that key. The definition of multimap includes a typedef to this pair called value_type.

The types used for both the template parameters Key and T must include the following (where T is the type, t is a value of T and u is a const value of T):

Copy constructors

T(t) and T(u)

Destructor

t.~T()

Address of

&t and &u yielding T* and const T* respectively

Assignment

t = a where a is a (possibly const) value of T

The type used for the Compare template parameter must satisfy the requirements for binary functions.

Interface

Constructors

explicit multimap(const Compare& comp = Compare(),
                  const Allocator& alloc = Allocator());
template <class InputIterator>
multimap(InputIterator start,
          InputIterator finish,
          const Compare& comp = Compare()
          const Allocator& alloc = Allocator());
multimap(const multimap<Key, T, Compare, Allocator>& x);

Assignment Operators

multimap<Key, T, Compare, Allocator>& 
operator=(const multimap<Key, T, Compare, Allocator>& x);

Allocators

allocator_type 
get_allocator() const;

Iterators

iterator 
begin();
const_iterator 
begin() const;
iterator 
end();
const_iterator 
end() const;
reverse_iterator 
rbegin();
const_reverse_iterator 
rbegin() const;
reverse_iterator 
rend();
const_reverse_iterator 
rend() const;

Member Functions

void
clear();
size_type 
count(const key_type& x) const;
bool 
empty() const;
pair<iterator,iterator> 
equal_range(const key_type& x);
pair<const_iterator,const_iterator> 
equal_range(const key_type& x) const;
void
erase(iterator start, iterator finish);
void
erase(iterator position);
size_type 
erase(const key_type& x);
iterator 
find(const key_type& x);
const_iterator 
find(const key_type& x) const;
iterator 
insert(const value_type& x);
iterator 
insert(iterator position, const value_type& x);
template <class InputIterator>
void 
insert(InputIterator start, InputIterator finish);
key_compare 
key_comp() const;
iterator 
lower_bound(const key_type& x);
const_iterator 
lower_bound(const key_type& x) const;
size_type 
max_size() const;
size_type 
size() const;
void 
swap(multimap<Key, T, Compare, Allocator>& x);
iterator
upper_bound(const key_type& x);
const_iterator 
upper_bound(const key_type& x) const;
value_compare 
value_comp() const;

Nonmember Operators

bool 
operator==(const multimap<Key, T, Compare, Allocator>& x,
           const multimap<Key, T, Compare, Allocator>& y);
bool 
operator!=(const multimap<Key, T, Compare, Allocator>& x,
           const multimap<Key, T, Compare, Allocator>& y);
bool 
operator<(const multimap<Key, T, Compare, Allocator>& x,
           const multimap<Key, T, Compare, Allocator>& y);
bool 
operator>(const multimap<Key, T, Compare, Allocator>& x,
           const multimap<Key, T, Compare, Allocator>& y);
bool 
operator<=(const multimap<Key, T, Compare, Allocator>& x,
           const multimap<Key, T, Compare, Allocator>& y);
bool 
operator>=(const multimap<Key, T, Compare, Allocator>& x,
           const multimap<Key, T, Compare, Allocator>& y);

Specialized Algorithms

template<class Key, class T, class Compare, class Allocator>
void swap(multimap<Key, T, Compare, Allocator>& a,
           multimap<Key, T, Compare, Allocator>& b);

Example

Warnings

Member function templates are used in all containers included in the Standard Template Library. For example, the constructor for multimap takes two templatized iterators:

multimap also has an insert function of this type. These functions, when not restricted by compiler limitations, allow you to use any type of input iterator as arguments. For compilers that do not support this feature, substitute functions allow you to use an iterator obtained from the same type of container as the one you are constructing (or calling a member function on), or you can use a pointer to the type of element you have in the container.

For example, if your compiler does not support member function templates, you can construct a multimap in the following two ways:

You cannot construct a multimap this way:

since the long_multimap and first_multimap are not the same type.

If your compiler does not support default template parameters, you must always supply the Compare template argument and the Allocator template argument. For instance, you must write:

multimap<int, int, less<int>, allocator<int> >

instead of:

multimap<int, int>

See Also

allocator, Containers, Iterators, map

Standards Conformance

ISO/IEC 14882:1998 -- International Standard for Information Systems -- Programming Language C++, Section 23.3.1



Previous fileTop of DocumentContentsIndex pageNext file