STL(Standard Template Library) - Container - List

리스트는 선형의 형태의 자료구조형입니다.

#include<iostream>
#include<list>
 
void print(std::list<int> Target_List)
{
    for (std::list<int>::iterator IterPos = Target_List.begin(); IterPos != Target_List.end(); ++IterPos)
        std::cout << *IterPos<<" ";
    std::cout << std::endl;
}
bool single_digit(const int& value) 
{ 
    if (value < 3)
        return true;
    else
        return false;
}
 

 
void main()
{
    std::list<int> List;
    std::list<int> List_Copy;
    std::list<int>::iterator Iter;
    std::list<int>::iterator Iter2;
 
    //if List is empty return true
    std::cout << std::endl << "empty()" << std::endl;
    if (List.empty())
        std::cout << "List is empty!" << std::endl;
 
    //assign(x,y) function insert y 'x' dataes
    std::cout << std::endl << "assign()" << std::endl;
    List.assign(3, 7);
    print(List);
 
    //push_back(x) write 'x' next to the last data in List
    std::cout << std::endl << "push_back()" << std::endl;
    List.push_back(4);
    print(List);
    List.push_back(2);
    print(List);
    List.push_back(1);
    print(List);
 
    //back() function return value the last data in List
    std::cout << std::endl << "back()" << std::endl;
    std::cout << List.back() << std::endl;
 
    //begin() function return Iterator that point first data in List
    std::cout << std::endl << "begin()" << std::endl;
    std::cout << *List.begin() << std::endl;
 
    //cbegin() function return const Iterator that point first data in List
    std::cout << std::endl << "cbegin()" << std::endl;
    std::cout << *List.cbegin() << std::endl;
 
    //cend() function return const Iterator that point next to the last data in List
    std::cout << std::endl << "cend()" << std::endl;
    std::cout << *(--List.cend()) << std::endl;
 
    //operator 'x1 = x2' copy x2 to x1
    std::cout << std::endl << "operator '=' " << std::endl;
    std::cout << "Previous List ->"; print(List);
    std::cout << "Previous List_Copy ->"; print(List_Copy);
    List_Copy = List;
    std::cout << "After List ->"; print(List);
    std::cout << "After List_Copy ->"; print(List_Copy);
 
    //clear() function remove all data in List
    std::cout << std::endl << "clear()" << std::endl;
    std::cout << "Previous List_Copy ->"; print(List_Copy);
    List_Copy.clear();
    std::cout << "After List_Copy ->"; print(List_Copy);
 
    //crbegin() function return const Iterator that point first data in List(reverse)
    std::cout << std::endl << "crbegin()" << std::endl;
    std::cout << *List.crbegin() << std::endl;
 
    //crend() function return constIterator that point next to the last data in List(reverse)
    std::cout << std::endl << "crend()" << std::endl;
    std::cout << *(--List.crend()) << std::endl;
 
    //emplace(x,y) function write 'y' in x position
    std::cout << std::endl << "emplace(x,y)" << std::endl;
    print(List);
    List.emplace(List.begin(),3);
    print(List);
 
    //emplace_back(x) function write 'x' next to last data in List
    std::cout << std::endl << "emplace_back(x)" << std::endl;
    print(List);
    List.emplace_back(14);
    print(List);
 
    //emplace_front(x) function write 'x' next to last data in List
    std::cout << std::endl << "emplace_front(x)" << std::endl;
    print(List);
    List.emplace_front(5);
    print(List);
 
    //end() function return pointer that point next to last data in List
    std::cout << std::endl << "end()" << std::endl;
    std::cout << *(--List.end()) << std::endl;
 
    //erase(x) function erase that iterator 'x' points int List 
    std::cout << std::endl << "erase()" << std::endl;
    List.erase(++List.begin());
    
    //front() function return first data in List
    std::cout << std::endl << "front()" << std::endl;
    std::cout << List.front() << std::endl;
 
    //insert(x,y) function insert y at position that Iterator x points
    std::cout << std::endl << "insert(x,y)" << std::endl;
    std::cout << "Previous List ->"; print(List);
    List.insert(List.end(),5);
    std::cout << "After List ->"; print(List);
 
    //max_size() function display list's max_size()
    std::cout << std::endl << "max_size()" << std::endl;
    std::cout<<List.max_size()<<std::endl;
    
    //sort() function sort dataes in the list in descending power 
    std::cout << std::endl << "sort()" << std::endl;
    std::cout << "Previous List ->"; print(List);
    List.sort();
    //List.sort(single_digit);//with function
    std::cout << "After List ->"; print(List);
 
    //x.merge(y) function merge two lists/ first, two lists be sorted with sort() function before merge
    //After merging, Data in list 'y' will be deleted.
    List_Copy.push_back(3);
    List_Copy.push_back(5);
    std::cout << std::endl << "merge()" << std::endl;
    std::cout << "List ->"; print(List);
    std::cout << "List_Copy ->"; print(List_Copy);
    List_Copy.sort();
    List.merge(List_Copy);
    //List.merge(List_Copy,single_digit);//with function
    std::cout << "After List ->"; print(List);
    std::cout << "After List_Copy ->"; print(List_Copy);
 
    //pop_back() function remove the last data in the list
    std::cout << std::endl << "pop_back()" << std::endl;
    std::cout << "Previous List ->"; print(List);
    List.pop_back();
    std::cout << "After List ->"; print(List);
    List.pop_back();
 
    //pop_front() function remove the first data int the list
    std::cout << std::endl << "pop_front()" << std::endl;
    std::cout << "Previous List ->"; print(List);
    List.pop_front();
    std::cout << "After List ->"; print(List);
    List.pop_back();
 
    //push_front(x) function write 'x' int front of first data in List
    std::cout << std::endl << "push_front()" << std::endl;
    std::cout << "Previous List ->"; print(List);
    List.push_front(4);
    std::cout << "After List ->"; print(List);
    
    //rbegin() function return Iterator that point first data in List(reverse)
    std::cout << std::endl << "rbegin()" << std::endl;
    std::cout << *List.rbegin() << std::endl;
 
    //remove(x) function remove all 'x' int List
    std::cout << std::endl << "remove()" << std::endl;
    std::cout << "Previous List ->"; print(List);
    List.remove(5);    
    std::cout << "After List ->"; print(List);
 
    //if remove_if() function receive true, remove that data 
    std::cout << std::endl << "remove_if()" << std::endl;
    List.remove_if(single_digit);
    print(List);
 
    //rend() function return Iterator that point next to the last data in List(reverse)
    std::cout << std::endl << "rend()" << std::endl;
    std::cout << *(--List.rend()) << std::endl;
 
    //resize() function modify sizeof List, if it be smaller than current size, it will loss some part of data.  
    std::cout << std::endl << "resize()" << std::endl;
    List.resize(10);
    print(List);
 
    //reverse() function reverse all data in List
    std::cout << std::endl << "reverse()" << std::endl;
    List.reverse();
    print(List);
 
    //size() function display list's size
    std::cout << std::endl << "size()" << std::endl;
    std::cout << List.size() << std::endl;
 
    //splice() function
    List_Copy.push_back(5);
    List_Copy.push_back(4);
    List_Copy.push_back(3);
    List_Copy.push_front(12);
    List.sort();
    List_Copy.sort();
    std::cout << std::endl << "splice()" << std::endl;
 
 
    //List.splice(Iter,List_Copy);//splice(x,y,z) y에서 z가 가리키는 것을 x에 복사함
    Iter = List.begin();
    Iter2 = --List_Copy.end();
    std::cout << "List_Cpoy (Previous) -> "; print(List_Copy);
    std::cout << "List(Previous) -> "; print(List);
    List.splice(Iter, List_Copy, Iter2);//copy data that Iter2 points in List_Copy to position that Iter points
    std::cout << "List (After) -> "; print(List);
    
        
    //x1.swap(x2) function swap x1 and x2;
    std::cout << std::endl << "swap()" << std::endl;
    std::cout << "List (Previous) -> "; print(List);
    std::cout << "List_Cpoy (Previous) -> "; print(List_Copy);
    List.swap(List_Copy);
    std::cout << "List (After) -> "; print(List);
    std::cout << "List_Cpoy (After) -> "; print(List_Copy);
 
    //In List if there are same values, unique() function integrate same values to one value 
    std::cout << std::endl << "unique()" << std::endl;
    std::cout << "Previous List_Copy ->"; print(List_Copy);
    List_Copy.unique(); 
 
    //List_Copy.unique(single_digit);//with function
    std::cout << "After List_Copy ->"; print(List_Copy);
}

각 함수들의 기능을 알아보겠습니다.(함수 이름을 클릭하면 자세한 내용을 볼 수 있습니다)

1. empty()
   
   비어있는지 비어있지 않은지에 따라서 비어있으면 true를 값이 있으면 false를 리턴합니다.
   
   
2. assign(x,y)
   
   y개의 x를 리스트에 삽입니다.
   
   
3. push_back(x)
   
   데이터 'x'를 리스트의 뒤쪽에 삽입니다.
   
   
4. back()
   
   리스트의 가장 마지막에 있는 데이터를 리턴합니다.
   
   
5. begin()
   
   첫 데이터를 가리키는 이터레이터를 리턴합니다.
   
   
6. cbegin()
   
   첫 데이터를 가리키는 const 이터레이터를 리턴합니다.
   
   
7. cend()
   
   리스트의 가장 마지막에 있는 데이터 바로 다음을 가리키는 이터레이터를 리턴합니다.
   
   
8. Operator =
   
   리스트끼리 대입하는 연산자 입니다. A=B 를 하면 B의 모든 데이터가 A로 복사되며 A의 이전데이터는 삭제됩니다.
   
   
9. clear()
   
   리스트에 있는 모든 데이터를 지웁니다.
   
   
10. crbegin()
    
    반대 리스트에서 첫 데이터를 가리키는 const 이터레이터를 리턴합니다.
    
    
11. crend()
    
    반대 리스트에서 가장 마지막 리스트의 바로 다음을 가리키는 const 이터레이터를 리턴합니다.
    
    
12. emplace(x,y)
    
    x위치에 y 데이터를 삽입니다.
    
    
13. emplace_back(x)
    
    리스트 가장 마지막에 x를 넣습니다.
    
    
14. emplace_front(x)
    
    리스트 가장 앞에 x를 너습니다.
    
    
15. end()
    
    리스트에서 가장 마지막 데이터 다음을 가리키는 이터레이터를 리턴합니다.
    
    
16. erase(x)
    
    이터레이터 x 가 가리키는 데이터를 삭제합니다.
    
    
17. front()
    
    리스트에서 제일 앞에 있는 데이터를 리턴합니다.
    
    
18. insert(x,y)
    
    이터레이터 x가 가리키고 있는 위치에 y데이터를 대입합니다.
    
    
19. max_size()
    
    리스트의 최대 크기를 리턴합니다.
    
    
20. sort()
    
    모든 데이터를 내림차순으로 정렬을 합니다.
    
    
21. x.merge(y)
    
    x와 y를 합병합니다. 단, x와 y는 미리 sort()함수를 통해서 정렬해야하며 합병이 끝난후에는 y는 삭제됩니다.
    
    
    x.merge(y,function)
    
    x와 y를 합병하되 y중에 function함수에 부합하는 값들만 합병합니다.
    
    
22. pop_back()
    
    리스트의 가장 마지막 데이터를 삭제합니다.
    
    
23. pop_front()
    
    리스트의 가장 첫 데이터를 삭제합니다.
    
    
24. push_front(x)
    
    리스트 제일 앞에 데이터 x를 삽입니다.
    
    
25. rbegin()
    
    반대 리스트에서 첫 데이터를 가리키는 이터레이터를 리턴합니다.
    
    
26. remove(x)
    
    리스트에 있는 모든 x를 삭제합니다.
    
    
27. remove_if(function)
    
    function 함수에 부합하는 값을 삭제합니다.
    
    
28. rend()
    
    반대 리스트에서 마지막 데이터 바로 다음을 가리키는 이터레이터를 리턴합니다.
    
    
29. resize(x)
    
    리스트의 사이즈를 x로 늘립니다. int형 리스트일때 10개 보다 값이 적었으면 0으로 채워 늘리고 부족할때는 넘는것을 삭제합니다.
    
    
30. reverse()
    
    리스트의 모든 데이터를 거꾸로 정렬합니다.
    
    
31. size()
    
    리스트의 현재 사이즈를 리턴합니다.
    
    
32. splice(x,y,z)
    
    리스트 y에서 z가 가리키는 데이터를 x가 가리키는 위치에 복사합니다.
    
    
33. x.swap(y)
    
    x와 y의 내용을 교체합니다.
    
    
34. unique()
    
    리스트내에서 중복되는 데이터를 하나로 합쳐서 표현합니다. 예를 들어  0 0  1 2 3 3 3 4 4 처럼 입력되어있을때는 0 1 2 3 4 처럼 수정이 됩니다.