STL(Standard Template Library) - Container - Map

Map은 pair단위로 데이터를 저장하며 set과같이 이진탐색트리로 구성이 되어있으면서도 key와 값 2개의 pair로 저장이 된다는 특징이 있습니다. 앞의

key를 이용하여 뒤의 값을 찾게됩니다. 오름차순으로 정렬이 되며 정렬기준은 key값을 기준으로 합니다.

#include<iostream>
#include<map>
#include<string>
void print(std::map<std::string, std::string> Target_map)
{
    for (std::map<std::string, std::string>::iterator IterPos = Target_map.begin(); IterPos != Target_map.end(); ++IterPos)
        std::cout << IterPos->first << "-" << IterPos->second << " , ";
    std::cout << std::endl;
}
bool length(std::map<std::string, std::string>::iterator Target_Iter)
{
    if (Target_Iter->first.length() > 2)
        return true;
    else
        return false;
}
void main()
{
    std::map<std::string, std::string> Map;
    std::map<std::string, std::string> Map_copy;
    std::map<std::string, std::string>::iterator Iter;
 
    //insert() function insert data in front of Map
    std::cout << std::endl << "insert()" << std::endl;
    print(Map);
    Map.insert(std::pair<std::string, std::string>("First", "1"));
    Map.insert(std::pair<std::string, std::string>("Second", "2"));
    Map.insert(std::pair<std::string, std::string>("Third", "3"));
    Map.insert(std::pair<std::string, std::string>("First", "1"));
    print(Map);
 
    //at(x) function return value at pair that have key x
    std::cout << std::endl << "at()" << std::endl;
    std::cout << Map.at("First") << std::endl;
 
    //begin() function return Iterator that point first pair
    std::cout << std::endl << "begin()" << std::endl;
    std::cout << Map.begin()->first << " " << Map.begin()->second << " " << std::endl;
 
    //cbegin() function return const Iterator that point first pair
    std::cout << std::endl << "cbegin()" << std::endl;
    std::cout << Map.cbegin()->first << " " << Map.cbegin()->second << " " << std::endl;
 
    //cend() function return const Iterator that point next to last pair
    std::cout << std::endl << "cend()" << std::endl;
    std::cout << (--Map.cend())->first << " " << (--Map.cend())->second << " " << std::endl;
 
    //Operator ' x1 = x2' copy x2 to x1
    std::cout << std::endl << "Operator '='" << std::endl;
    std::cout << "Previous Map ---> "; print(Map);
    std::cout << "Previous Map_Copy ---> "; print(Map_copy);
    Map_copy = Map;
    std::cout << "After Map ---> "; print(Map);
    std::cout << "After Map_Copy ---> "; print(Map_copy);
 
    //clear() function clear all data in Map
    std::cout << std::endl << "clear()" << std::endl;
    std::cout << "Previous Map_Copy ---> "; print(Map_copy);
    Map_copy.clear();
    std::cout << "After Map_Copy ---> "; print(Map_copy);
 
    //count(x) function return number of x
    std::cout << std::endl << "count()" << std::endl;
    std::cout << Map.count("First") << std::endl;
 
    //crbegin() function return const Iterator that point first pair (reverse)
    std::cout << std::endl << "crbegin()" << std::endl;
    std::cout << Map.crbegin()->first << " " << Map.crbegin()->second << " " << std::endl;
 
    //crend() function return const Iterator that point next to last pair (reverse)
    std::cout << std::endl << "crend()" << std::endl;
    std::cout << (--Map.crend())->first << " " << (--Map.crend())->second << " " << std::endl;
 
    //emplace() function insert data in map
    std::cout << std::endl << "emplace()" << std::endl;
    std::cout << "Previous Map ---> "; print(Map);
    Map.emplace(std::pair<std::string, std::string>("fourth", "4"));
    std::cout << "After Map ---> "; print(Map);
 
    //emplace_hint(x,y) function insert data 'y' at position that Iterator x points in Map
    std::cout << std::endl << "emplace_hint()" << std::endl;
    std::cout << "Previous Map ---> "; print(Map);
    Map.emplace_hint(++(Map.begin()), std::pair<std::string, std::string>("fifth", "5"));
    std::cout << "After Map ---> "; print(Map);
 
    //if Map is empty, empty() function return true
    std::cout << std::endl << "empty()" << std::endl;
    if (Map.empty())
        std::cout << "Map is empty" << std::endl;
    else
        std::cout << "Map is not empty" << std::endl;
 
    //end() function return Iterator that point next to last pair
    std::cout << std::endl << "end()" << std::endl;
    std::cout << (--Map.end())->first << " " << (--Map.end())->second << " " << std::endl;
 
    
    //erase(x) remove pair that left pair has 'x'
    std::cout << std::endl << "erase()" << std::endl;
    print(Map);
    Map.erase("Third");
    print(Map);
 
    //find(x) if x is not in map return end(), and can cange right pair value (NOT!! left(Key) value!!)
    std::cout << std::endl << "find()" << std::endl;
    print(Map);
    Iter = Map.find("First");
    if (Iter != Map.end())
        Iter->second = "1050";
    print(Map);
 
    //max_size() function return map's Max Size
    std::cout << std::endl << "max_size()" << std::endl;
    std::cout << " max_size ---> " << Map.max_size() << std::endl;
 
    //In map Operator [] use like array's index with 'key' value 
    if (Map["First"] == Map.begin()->second)
        std::cout << "Same" << std::endl;
    else
        std::cout << " Not Same" << std::endl;
 
    //rbegin() function return Iterator that point first pair (reverse)
    std::cout << std::endl << "rbegin()" << std::endl;
    std::cout << Map.rbegin()->first << " " << Map.rbegin()->second << " " << std::endl;
 
    //rend() function return Iterator that point next to last pair (reverse)
    std::cout << std::endl << "rend()" << std::endl;
    std::cout << (--Map.rend())->first << " " << (--Map.rend())->second << " " << std::endl;
 
    //size() function return value that size of Map
    std::cout << std::endl << "size()" << std::endl;
    std::cout << " size ---> " << Map.size() << std::endl;
 
    //x1.swap(x2) function swap x1 and x2
    std::cout << std::endl << "swap()" << std::endl;
    std::cout << "Previous Map ---> "; print(Map);
    std::cout << "Previous Map_Copy ---> "; print(Map_copy);
    Map.swap(Map_copy);
    std::cout << "After Map ---> "; print(Map);
    std::cout << "After Map_Copy ---> "; print(Map_copy);
 
    //equal_reange() function return upper_bound and lower bound
    std::cout << std::endl << "eqyal_range(\"First\")" << std::endl;
    std::pair < std::map<std::string, std::string>::iterator, std::map<std::string, std::string>::iterator> Pair_Iter;
    Pair_Iter = Map_copy.equal_range("First");
    std::cout << Pair_Iter.first->first<<"<->"<< Pair_Iter.first->second << " & " << Pair_Iter.second->first << "<->" << Pair_Iter.second->second << std::endl;
 
    //lower_bound() function return Iterator that point minimum value bigger than x(or point equal)
    std::cout << std::endl << "lower_bound(\"First\")"<< std::endl;
    Iter = Map_copy.lower_bound("First");
    std::cout << "lower_bound(\"First\") ----> " << Iter->first << " <-> " << Iter->second << std::endl;
    
    //upper_bound() function return Iterator that point minimum value bigger than x(Not Equal)
    std::cout << std::endl << "upper_bound(\"First\")" << std::endl;
    Iter = Map_copy.upper_bound("First");
    std::cout << "upper_bound(\"First\") ----> " << Iter->first << " <-> " << Iter->second << std::endl;
 
    //try_emplace(x,y) function insert data if same key(x) is not exist in Map
    print(Map_copy);
    Map_copy.try_emplace("Rock","4");
    print(Map_copy);
 
    //if to compare sort [y,z) and x is same ,x.key_comp(y,z)  return true
    std::cout << std::endl << "key_comp()" << std::endl;
    std::map<std::string, std::string>::key_compare Key = Map_copy.key_comp();
    if(Key("a", "b"))
        std::cout << "Same" << std::endl;
    else
        std::cout << "Not Same" << std::endl;
 
    //if to compare sort [y,z) and x is same ,x.value_comp(y,z)  return true
    std::cout << std::endl << "value_comp()" << std::endl;
    std::map<std::string, std::string>::value_compare Value = Map_copy.value_comp();
    if (Key("b", "a"))
        std::cout << "Same" << std::endl;
    else
        std::cout << "Not Same" << std::endl;
}

각 함수의 기능을 알아보겠습니다.

1. insert(pair(x,y))
   
   맵에 데이터를 삽입합니다. 값 삽입은 pair단위로 하게됩니다.
   
   
2. at(x)
   
   key값이 x인 pair를 찾아서 그 value를 리턴합니다.
   
   
3. begin()
   
   맵에서 가장 앞에 있는 첫 pair를 가리키는 이터레이터를 리턴합니다.
   
   
4. cbegin()
   
   맵에서 가장 앞에 있는 첫 pair를 가리키는 const 이터레이터를 리턴합니다.
   
   
5. cend()
   
   맵에서 가장 가장 마지막에 있는 pair 바로 다음을 가리키는 const 이터레이터를 리턴합니다.
   
   
6. Operator '='
   
   x1=x2  맵 x1에다 맵 x2의 데이터를 복사합니다. 기존의 맵 x1의 데이터는 삭제됩니다.
   
   
7. clear()
   
   맵 내부의 모든 데이터를 삭제합니다.
   
   
8. count(x)
   
   맵 내부에서 key값이 x인 것의 갯수를 리턴합니다.
   
   
9. crbegin()
   
   거꾸로 보는 맵에서 가장 처음을 가리키는 const 이터레이터를 리턴합니다.
   
   
10. crend()
    
    거꾸로 보는 맵에서 가장 마지막 바로 다음을 가리키는 const 이터레이터를 리턴합니다.
    
    
11. emplace(pair(x,y))
    
    맵에 데이터를 삽입 합니다. pair단위로 삽입합니다.
    
    
12. emplace_hint(x,pair(y,z))
    
    이터레이터 x가 가리키는 위치에 데이터를 삽입합니다.
    
    
13. empty()
    
    맵이 비었으면 true를 리턴하고 비어있지 않으면 false를 리턴합니다.
    
    
14. emd()
    
    맵에서 가장 마지막 pair 바로 다음을 가리키는 이터레이터를 리턴합니다.
    
    
15.  erase(x)
    
    key값이 x인 pair를 삭제합니다.
    
    
16. find(x)
    
    key값이 x를 찾습니다. 없으면 end()를 반환하며 find를 이용하여 찾은 값을 변경할때 key값은 변경 할 수 없습니다.
    
    
17. max_size()
    
    맵의 최대값을 리턴합니다.
    
    
18. Operator []
    
    맵 에서는 배열과 같이 맵 내부의 key 값들을 이용하여 직접 위치에 접근할 수 있습니다.
    
    
19. rbegin()
    
    거꾸로 보는 맵에서 첫 pair를 가리키는 이터레이터를 리턴합니다.
    
    
20. rend()
    
    거꾸로 보는 맵에서 가장 마지막 pair 바로 다음을 가리키는 이터레이터를 리턴합니다.
    
    
21. size()
    
    맵의 사이지를 리턴합니다.
    
    
22. swap()
    
    x.swap(y) 맵 x와 맵 y를 이름빼고 모두다 교체합니다.
    
    
23. equal_range(x)
    
    first로 lower_range(x)의 pair로 second로 upper_range(x)의 pair를 가르키는 pair를 리턴합니다.
    
    
24. lower_bound(x)
    
    x보다 큰 값들 중에서 가장 작은 값(또는 같은 값)을 가리키는 이터레이터를 리턴합니다.
    
    
25. upper_bound(x)
    
    x보다 큰 값들 중에서 가장 작은 값(같은 값 제외)을 가리키는 이터레이터를 리턴합니다.
    
    
26. emplace(pair(x,y))
    
    맵에 데이터를 삽입합니다.
    
    
27. key_comp(x,y)
    
    맵의 현재 정렬상태와 x,y의 정렬상태를 비교하여 같으면 true를 리턴하고 다르면 false를 리턴합니다. 위의 소스를 예시로 들면 b,a라고 되어있는 것은 내림차순이라는 것을 a,b라고 되어있는 것은 오름차순을 의미하며 맵은 오름차순으로 정렬되기 때문에 a,b순서와 비교했을 때 true값을 리턴하게됩니다.
    
    
28. value_comp(pair,pair)
    
    pair 두개의 정렬상태와 map내부의 pair들의 정렬상태를 비교하여 같으면 true를 리턴합니다.