Node:Multimap, Previous:Map, Up:Associative containers

Multimap

multimap

Associative Container

multimap is a kind of associative container (See Associative containers.) that supports equal keys (possibly contains multiple copies of the same key value) and provides for fast retrieval of values of another type T based on the keys. See Reversible Container.

template ,
          template  class Allocator = allocator>
class multimap {
public:

// typedefs:
    typedef Key key_type;
    typedef pair value_type;
    typedef Compare key_compare;
    class value_compare
    : public binary_function {
        friend class multimap;
    protected:
        Compare comp;
        value_compare(Compare c) : comp(c) {}
    public:
        bool operator()(const value_type& x, const value_type& y) {
            return comp(x.first, y.first);
        }
    };
    typedef iterator;
    typedef const_iterator;
    typedef Allocator::pointer pointer;
    typedef Allocator::reference reference;
    typedef Allocator::const_reference const_reference;
    typedef size_type;
    typedef difference_type;
    typedef reverse_iterator;
    typedef const_reverse_iterator;

// allocation/deallocation:
    multimap(const Compare& comp = Compare());
    template 
    multimap(InputIterator first, InputIterator last,
             const Compare& comp = Compare());
    multimap(const multimap& x);
    ~multimap();
    multimap&
        operator=(const multimap& x);
    void swap(multimap& x);

// accessors:
    key_compare key_comp() const;
    value_compare value_comp() const;
    iterator begin();
    const_iterator begin() const;
    iterator end();
    const_iterator end() const;
    reverse_iterator rbegin();
    const_reverse_iterator rbegin();
    reverse_iterator rend();
    const_reverse_iterator rend();
    bool empty() const;
    size_type size() const;
    size_type max_size() const;

// insert/erase:
    iterator insert(const value_type& x);
    iterator insert(iterator position, const value_type& x);
    template 
    void insert(InputIterator first, InputIterator last);
    void erase(iterator position);
    size_type erase(const key_type& x);
    void erase(iterator first, iterator last);

// multimap operations:
    iterator find(const key_type& x);
    const_iterator find(const key_type& x) const;
    size_type count(const key_type& x) const;
    iterator lower_bound(const key_type& x);
    const_iterator lower_bound(const key_type& x) const;
    iterator upper_bound(const key_type& x);
    const_iterator upper_bound(const key_type& x) const;
    pair equal_range(const key_type& x);
    pair equal_range(const key_type& x) const;
};

template 
bool operator==(const multimap& x,
                const multimap& y);

template 
bool operator<(const multimap& x,
               const multimap& y);

iterator

Typedef on multimap

iterator is a bidirectional iterator referring to value_type. The exact type is implementation dependent and determined by Allocator.

const_iterator

Typedef on multimap

const_iterator is the a constant bidirectional iterator referring to const value_type. The exact type is implementation dependent and determined by Allocator. It is guaranteed that there is a constructor for const_iterator out of iterator.

size_type

Typedef on multimap

size_type is an unsigned integral type. The exact type is implementation dependent and determined by Allocator.

difference_type

Typedef on multimap

difference_type is a signed integral type. The exact type is implementation dependent and determined by Allocator.