map은 이진탐색 트리로 구현됨
key와 value로 구성됨 >> std::pair사용(구현)

template < class Key, class T, class Compare = less<Key>, 
           class Alloc = allocator<pair<const Key,T> > > class map;

< class > compare

키 값 비교를 통해 hash_map의 요소를 비교하여 hash_map 내의 상대 순서를 확인할 수 있는 함수 개체를 제공합니다.

std::less< T >

두개의 인자를 받아 왼쪽이 오른쪽보다 작은지를 true false 로 반환한다.

멤버 타입

private

• tree_type
• self
• tree

함수

construct

map (const key_compare& comp = key_compare(),
              const allocator_type& alloc = allocator_type());

template <class InputIterator>
map (InputIterator first, InputIterator last,
       const key_compare& comp = key_compare(),
       const allocator_type& alloc = allocator_type());
	
map (const map& x);

destructor

~map();

operator=

map& operator= (const map& x);

- Iterators

begin / end / rbegin / rend

iterator OOO();
const_iterator OOO() const;

- Capacity

size

size_type size() const;

=> return (len)

max_size

size_type max_size() const;

return (numeric_limits<difference_type>::max() / sizeof(T))

empty

bool empty() const;

return (this->len == 0)

- Element access

operator[]

mapped_type& operator[] (const key_type& k);

- Modifiers

insert

pair<iterator,bool> insert (const value_type& val);
iterator insert (iterator position, const value_type& val);
template <class InputIterator>
  void insert (InputIterator first, InputIterator last);

erase

void erase (iterator position);	
size_type erase (const key_type& k);
void erase (iterator first, iterator last);

swap

void swap (map& x);

clear

void clear();

- Observers

key_comp

key_compare key_comp() const;

value_comp

value_compare key_comp() const;

- Operations

find

      iterator find (const key_type& k);
const_iterator find (const key_type& k) const;

count

size_type count (const key_type& k) const;

lower_bound / upper_bound

iterator OOO_bound (const key_type& k);
const_iterator OOO_bound (const key_type& k) const;

equal_range

pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
pair<iterator,iterator>             equal_range (const key_type& k);