STL(Standard Template Library) - Container - Deque

Deque은 Queue와는 다르게 들어가는 방향과 나가는 방향이 정해진 것이 아니라 어디로든 들어갈 수 있고 어디로든 나올 수 있는 자료구조입니다.

#include<iostream>
#include<deque>
 
void print(std::deque<int> Target_Deque)
{
    for (std::deque<int>::iterator Iter = Target_Deque.begin(); Iter != Target_Deque.end(); ++Iter)
        std::cout << *Iter<<" ";
    std::cout << std::endl;
}
 
void main()
{
    std::deque<int> Deque;
    std::deque<int> Deque_Copy;
    std::deque<int>::iterator Iter;
 
    //assign(3,4) function 3(three) '4's in this deque
    std::cout << std::endl << "assign(x,y)" << std::endl;
    Deque.assign(3, 4);
    print(Deque);
 
    //push_back() function write data next to las data in deque
    std::cout << std::endl << "push_back()" << std::endl;
    Deque.push_back(5);
    print(Deque);
 
    //push_front() function write data at previous of first data in deque
 
    std::cout << std::endl << "push_front()" << std::endl;
    Deque.push_front(1);
    print(Deque);
 
    //at(x) function return data in x(th) in deque
    std::cout << std::endl << "at(2)" << std::endl;
    std::cout << Deque.at(2) << std::endl;
 
    //back() function return the last data in deque
    std::cout << std::endl << "back()" << std::endl;
    std::cout << Deque.back() << std::endl;
 
    //begin() function return Iterator that point first data in deque
    std::cout << std::endl << "begin()" << std::endl;
    std::cout << *Deque.begin() << std::endl;
 
    //cbegin() function return const Iterator that point first data in deque
    std::cout << std::endl << "cbegin()" << std::endl;
    std::cout << *Deque.cbegin() << std::endl;
 
    //cend() function return const Iterator that point next to last data in deque
    std::cout << std::endl << "cend()" << std::endl;
    std::cout << *(--Deque.cend()) << std::endl;
 
    //operator ' x1 = x2 ' copy x2 to x1
    std::cout << std::endl << "Operator '='" << std::endl;
    std::cout << "Previous Deque ->"; print(Deque);
    std::cout << "Previous Deque_Copy ->"; print(Deque_Copy);
    Deque_Copy = Deque;
    std::cout << "After Deque ->"; print(Deque);
    std::cout << "After Deque_Copy ->"; print(Deque_Copy);
 
    //clear() function clear all data in deque
    std::cout << std::endl << "clear()" << std::endl;
    std::cout << "Previous Deque_Copy ->"; print(Deque_Copy);
    Deque_Copy.clear();
    std::cout << "After Deque_Copy ->"; print(Deque_Copy);
 
    //crbegin() function return const Iterator that point first data in deque(reverse)
    std::cout << std::endl << "crbegin()" << std::endl;
    std::cout << *Deque.crbegin() << std::endl;
 
    //crend() function return const Iterator that point next to last data in deque(reverse)
    std::cout << std::endl << "crend()" << std::endl;
    std::cout << *(--Deque.crend()) << std::endl;
 
    //emplace(x,y) function write data at position that Iterator x points in deque 
    std::cout << std::endl << "emplace()" << std::endl;
    std::cout << "Previous Deque ->"; print(Deque);
    Deque.emplace(Deque.begin() + 3, 14);
    std::cout << "After Deque ->"; print(Deque);
 
    //emplate_back() function write data at last in deque
    std::cout << std::endl << "emplace_back()" << std::endl;
    std::cout << "Previous Deque ->"; print(Deque);
    Deque.emplace_back(5);
    std::cout << "After Deque ->"; print(Deque);
 
    //emplate_front() function write data at first in deque
    std::cout << std::endl << "emplace_front()" << std::endl;
    std::cout << "Previous Deque ->"; print(Deque);
    Deque.emplace_front(125);
    std::cout << "After Deque ->"; print(Deque);
 
    //If deque is empty, empty() function return true
    std::cout << std::endl << "empty()" << std::endl;
    if (Deque.empty())
        std::cout << "Deque is empty" << std::endl;
    else
        std::cout << "Deque is not empty" << std::endl;
 
    //end() function return Iterator that point next to last data in deque
    std::cout << std::endl << "end()" << std::endl;
    std::cout << *(--Deque.end()) << std::endl;
 
    //erase(x) function erase data at position that specific iterator x point
    std::cout << std::endl << "erase()" << std::endl;
    Deque.erase(Deque.cbegin());
    print(Deque);
    //Deque.erase(++Deque.begin(), --Deque.end());//erase(x,y) erase all data in [x,y) in deque
    //print(Deque);
 
    //front() function return first value in deque
    std::cout << std::endl << "front()" << std::endl;
    std::cout << Deque.front() << std::endl;
 
    //insert(x,y) function insert data y at position that Iterator x points
    std::cout << std::endl << "insert()" << std::endl;
    std::cout << "Previous Deque ->"; print(Deque);
    Deque.insert(Deque.begin(), 1234);
    std::cout << "After Deque ->"; print(Deque);
 
    //max_size() function return deque's max_size
    std::cout << std::endl << "max_size()" << std::endl;
    std::cout << Deque.max_size() << std::endl;
 
    //Deque can express like array
    std::cout << std::endl << "Operator '[]'" << std::endl;
    if (Deque[0] == *Deque.begin())
        std::cout << "Same" << std::endl;
    else
        std::cout << "different" << std::endl;
 
    //pop_back() function remove last data in deque
    std::cout << std::endl << "pop_back()" << std::endl;
    std::cout << "Previous Deque ->"; print(Deque);
    Deque.pop_back();
    std::cout << "After Deque ->"; print(Deque);
 
    //pop_back() function remove first data in deque
    std::cout << std::endl << "pop_front()" << std::endl;
    std::cout << "Previous Deque ->"; print(Deque);
    Deque.pop_front();
    std::cout << "After Deque ->"; print(Deque);
 
    //push_back() function write last data in deque
    std::cout << std::endl << "pop_front()" << std::endl;
    std::cout << "Previous Deque ->"; print(Deque);
    Deque.push_back(52);
    std::cout << "After Deque ->"; print(Deque);
 
    //push_front() function write first data in deuqe
    std::cout << std::endl << "pop_front()" << std::endl;
    std::cout << "Previous Deque ->"; print(Deque);
    Deque.push_front(42);
    std::cout << "After Deque ->"; print(Deque);
 
    //rbegin() function return Iterator that point first data in deque(reverse)
    std::cout << std::endl << "rbegin()" << std::endl;
    std::cout << *Deque.rbegin() << std::endl;
 
    //rend() function return Iterator that point next to last data in deque(reverse)
    std::cout << std::endl << "rend()" << std::endl;
    std::cout << *(--Deque.rend()) << std::endl;
 
    //resize(x) function modify deque size 
    std::cout << std::endl << "resize(x)" << std::endl;
    std::cout << "Previous Deque ->"; print(Deque);
    std::cout << "Previous Deque size->" << Deque.size() << std::endl;
    Deque.resize(7);
    std::cout << "After Deque ->"; print(Deque);
    std::cout << "After Deque size->" << Deque.size() << std::endl;
 
    //size() display size of this deque
    std::cout << std::endl << "size()" << std::endl;
    std::cout << "Size->" << Deque.size() << std::endl;
 
    //shrink_to_fit() function remove over byte
    std::cout << std::endl << "shrink_to_fit()" << std::endl;
    std::cout << "Previous Deque size->" << Deque.size() << std::endl;
    Deque.shrink_to_fit();
    std::cout << "After Deque size->" << Deque.size() << std::endl;
 
    //x1.swap(x2) function swap x1 and x2
    std::cout << std::endl << "swap" << std::endl;
    std::cout << "Previous Deque ->"; print(Deque);
    std::cout << "Previous Deque_Copy ->"; print(Deque_Copy);
    Deque.swap(Deque_Copy);
    std::cout << "After Deque ->"; print(Deque);
    std::cout << "After Deque_Copy ->"; print(Deque_Copy);
 
    
}

각 함수의 기능에 대해서 알아보겠습니다. (각 함수의 이름을 누르면 자세한 설명으로 이동합니다)

1. assign(x,y)
   
   x개의 y데이터를 덱에 할당합니다.
   
   
2. push_back(x)
   
   덱 가장 마지막 데이터 다음에 x를 넣습니다.
   
   
3. push_front(x)
   
   덱 가장 앞에 x를 넣습니다.
   
   
4. at(x)
   
   덱에서 x번째 데이터를 리턴합니다.
   
   
5. back()
   
   덱에서 가장 마지막에 있는 데이터를 리턴합니다.
   
   
6. begin()
   
   덱에서 가장 앞에 있는 데이터를 가리키는 이터레이터를 리턴합니다.
   
   
7. cbegin()
   
   덱에서 가장 앞에 있는 데이터를 가리키는 const 이터레이터를 리턴합니다.
   
   
8. cend()
   
   덱에서 마지막 데이터 바로 다음을 가리키는 const 이터레이터를 리턴합니다.
   
   
9. Operator '='
   
   a=b일경우 덱 b의 데이터를 덱 a로 모두 복사합니다. 기존 a의 데이터는 삭제합니다.
   
   
10. clear()
    
    덱에 있는 모든 데이터를 삭제합니다.
    
    
11. crbegin()
    
    거꾸로 보는 덱에서 제일 앞에 있는 데이터를 가리키는 const 이터레이터를 리턴합니다.
    
    
12. crend()
    
    거꾸로 보는 덱에서 제일 뒤에 있는 데이터 바로 다음을 가리키는 const 이터레이터를 리턴합니다.
    
    
13. emplace(x,y)
    
    이너레이터 x가 가리키는 위치에 y데이터를 집어넣습니다.
    
    
14. emplace_back(x)
    
    덱에서 가장 마지막에 x값을 삽입합니다.
    
    
15. emplace_front(x)
    
    덱에서 제일 앞에 x값을 삽입합니다.
    
    
16. empty()
    
    덱이 비었으면 true를 리턴하고 비지 않았으면 false를 리턴합니다.
    
    
17. end()
    
    덱의 가장 마지막 데이터 바로 다음을 가리키는 이터레이터를 리턴합니다.
    
    
18. erase(x)
    
    덱에서 x이터레이터가 가리키고 있는 값을 삭제합니다.
    
    erase(x,y)
    
    덱에서 x 이터레이터와 y이터레이터 사이의 모든 데이터를 삭제합니다.
    
    
19. front()
    
    덱에서 가장 앞에 있는 데이터를 리턴합니다.
    
    
20. insert(x,y)
    
    이터레이터 x 가 가리키고 있는 위치에 y를 대입합니다.
    
    
21. max_size()
    
    덱의 최대사이즈를 리턴합니다.
    
    
22. Operator []
    
    덱은 배열처럼 []연산자를 이용할 수 있습니다. deque[0]은 첫번째 요소를 가리킵니다.
    
    
23. pop_back()
    
    덱에서 가장 뒤에 있는 데이터를 삭제합니다.
    
    
24. pop_front()
    
    덱에서 가장 앞에 있는 데이터를 삭제합니다.
    
    
25. rbegin()
    
    거꾸로 본 덱에서 가장 앞을 가리키는 이터레이터를 리턴합니다.
    
    
26. rend()
    
    거꾸로 본 덱에서 가장 마지막 데이터 바로 다음을 가리키는 이터레이터를 리턴합니다.
    
    
27. resize(x)
    
    덱의 사이즈를 x로 변경합니다.
    
    
28. size()
    
    덱의 현재 사이즈를 리턴합니다.
    
    
29. shrink_to_fit()
    
    들어있는 데이터 만큼만으로 사이즈를 줄입니다.
    
    
30. swap()
    
    a.swap(b) a와 b를 이름빼고 완전히 바꿉니다.