C++ STL map 사용법

map 컨테이너

• 헤더 < map > 에 저장되어 있다.
• key와 value가 쌍으로 저장됩니다.
• 노드 기반으로 이루어져 균형 이진 트리 구조 입니다.
• key는 고유한 값이므로 중복이 불가능하지만, multimap 에서 중복을 지원합니다.
• compare 부분을 지정해주지않으면 삽입이 되면서 자동으로 정렬이 됩니다. (default 로 오름차순)
• 저장공간 필요에 따라서 allocator 객체 사용 (동적 할당을 위해서)
• set 과 아주 유사하다.

map의 템플릿 구조.

template < class Key,                                     // map::key_type
           class T,                                       // map::mapped_type
           class Compare = less<Key>,                     // map::key_compare
           class Alloc = allocator<pair<const Key,T> >    // map::allocator_type
           > class map;

멤버함수

• construtor 제공, destructor 제공.
• operator = 할당자함수도 제공한다.

요소 접근방법

• map[key]
  • 해당 key의 원소를 참조한다.
• map.at(key)
  • 해당 key의 원소를 참조한다.

Capacity

• empty();
  • size가 0이면 리턴 true, 아니면 리턴 false
• size();
  • 원소의 개수를 리턴한다.
• max_size();
  • 컨테이너가 보유할 수 있는 최대 요소 수 리턴.

반복자

• begin();
  • 맨 첫번째 원소를 가르키는 반복자를 리턴
• end();
  • 맨 마지막 원소를 가르키는 원소의 끝부분의 반복자를 리턴.
• rbegin();
• rend();
  • begin 과 end의 반대로 작동함.
• cbegin();
• cend();
• crbegin();
• crend();
  • 위의 것들과 동일하지만 const 키워드가 추가됨으로 써 가리키는 내용을 수정하는데 사용할 수 없다.

수정

• insert(iter, k);
  • iter가 가르키는 위치부터 k를 삽입할 위치를 탐색하여 삽입.
• erase();
  • erase(iter) -> iter가 가르키는 원소를 제거하고 그다음 원소를 가르키는 iter를 리턴.
  • erase(start, end) -> [start,end) 범위의 원소를 모두 제거.
• swap();
  • map.swap(map2); -> map2와 map1을 바꿔준다.
• clear();
  • 모든 원소를 제거하고 size0으로 남는다.
• emplace();
  • insert와 비슷하지만 삽입과 동시에 생성이 이루어짐.

Observers

• key_comp();
• value_comp();
  • 둘다 모두 정렬 기준 조건자를 리턴한다.

기능들

• find(key);
  • key 값을 가르키는 반복자를 리턴. 만약 없다면 end()와 같은 반복자 리턴.
• count(key);
  • key 값의 개수를 리턴한다. 0개 아니면 1개 key값은 중복이 불가능하기 때문.
• lower_bound(key);
  • key가 시작하는 구간의 반복자를 리턴.
• upper_bound(key);
  • key가 끝나는 구간의 반복자를 리턴
• equal_range(key);
  • key가 시작하는 구간과 끝나는 구간의 pair 객체를 반환.
  • upper_bound(key)와 lower_bound(key)가 합쳐진 함수.

Examples

다양한 생성 방법

// constructing maps
#include <iostream>
#include <map>

bool fncomp (char lhs, char rhs) {return lhs<rhs;}

struct classcomp {
  bool operator() (const char& lhs, const char& rhs) const
  {return lhs<rhs;}
};

int main ()
{
  std::map<char,int> first;

  first['a']=10;
  first['b']=30;
  first['c']=50;
  first['d']=70;

  std::map<char,int> second (first.begin(),first.end());

  std::map<char,int> third (second);

  std::map<char,int,classcomp> fourth;                 // class as Compare

  bool(*fn_pt)(char,char) = fncomp;
  std::map<char,int,bool(*)(char,char)> fifth (fn_pt); // function pointer as Compare

  return 0;
}

insert

#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  // first insert function version (single parameter):
  mymap.insert ( std::pair<char,int>('a',100) );
  mymap.insert ( std::pair<char,int>('z',200) );

  std::pair<std::map<char,int>::iterator,bool> ret;
  ret = mymap.insert ( std::pair<char,int>('z',500) );
  if (ret.second==false) {
    std::cout << "element 'z' already existed";
    std::cout << " with a value of " << ret.first->second << '\n';
  }

  // second insert function version (with hint position):
  std::map<char,int>::iterator it = mymap.begin();
  mymap.insert (it, std::pair<char,int>('b',300));  // max efficiency inserting
  mymap.insert (it, std::pair<char,int>('c',400));  // no max efficiency inserting

  // third insert function version (range insertion):
  std::map<char,int> anothermap;
  anothermap.insert(mymap.begin(),mymap.find('c'));

  // showing contents:
  std::cout << "mymap contains:\n";
  for (it=mymap.begin(); it!=mymap.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  std::cout << "anothermap contains:\n";
  for (it=anothermap.begin(); it!=anothermap.end(); ++it)
    std::cout << it->first << " => " << it->second << '\n';

  return
}

Output:

element 'z' already existed with a value of 200
mymap contains:
a => 100
b => 300
c => 400
z => 200
anothermap contains:
a => 100
b => 300

equal range

#include <iostream>
#include <map>

int main ()
{
  std::map<char,int> mymap;

  mymap['a']=10;
  mymap['b']=20;
  mymap['c']=30;

  std::pair<std::map<char,int>::iterator,std::map<char,int>::iterator> ret;
  ret = mymap.equal_range('b');

  std::cout << "lower bound points to: ";
  std::cout << ret.first->first << " => " << ret.first->second << '\n';

  std::cout << "upper bound points to: ";
  std::cout << ret.second->first << " => " << ret.second->second << '\n';

  return 0;
}

Output:

lower bound points to: 'b' => 20
upper bound points to: 'c' => 30

자세한 내용은 아래의 레퍼런스 참조 하세용
click reference site