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

map

Library:  Containers


Does not inherit

Local Index

Members

Non-Members

Summary

An associative container with access to non-key values using unique keys. A map 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 map;
}

Description

map gives fast access to stored values of type T that are indexed by unique keys of type Key. The default operation for key comparison is the < operator.

map has 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 map 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 map(const Compare& comp = Compare(),
             const Allocator& alloc = Allocator());
template <class InputIterator>
map(InputIterator start, InputIterator finish,
    const Compare& comp = Compare(),
    const Allocator& alloc = Allocator());
map(const map<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 Operators

map 
operator=(const map<Key, T, Compare, Allocator>& x);
mapped_type& 
operator[](const key_type& x);

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 position);
void
erase(iterator start, iterator finish);
size_type 
erase(const key_type& x);
iterator 
find(const key_type& x);
const_iterator 
find(const key_type& x) const; 
pair<iterator, bool> 
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(map<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

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

Specialized Algorithms

template <class Key, class T, class Compare, class Allocator>
void swap(map<Key, T, Compare, Allocator>& a,
           map<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 map takes two templatized iterators:

map 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 map in the following two ways:

You cannot construct a map this way:

Since the long_map and first_map are not the same type.

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

map<int, int, less<int>, allocator<int> >

instead of:

map<int, int>

See Also

allocator, Containers, Iterators, multimap

Standards Conformance

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



Previous fileTop of DocumentContentsIndex pageNext file