C++ STL总结（三）deque

1.deque内存结构

deque是双向开口的，即在头尾插入和删除元素效率都很高，逻辑上deque的内存结构是这样的

实际上，deque是用一个中控器map来管理这些连续的内存空间。map是一小块连续的空间，每个元素都是一个指针，指向连续的内存空间，指向的空间中存储的才是真正的deque的元素。

2.deque容量操作

函数	功能
bool empty()	检查容器是否为空
size_t size()	返回容器中元素的个数
size_t max_size()	返回容器由于系统或库的实现所限制可容纳的元素最大数量
void resize(size_t new_size, const T& x)	重设容器的size大小，如果size变大，则以默认值填充变长的位置，如果size变小，则删除变短那部分的尾部元素
void shrink_to_fit()	请求移除容器未使用的容量

void test_capacity(){
        deque<int> test;
        cout << "*************************after init****************************\n";
        cout << "empty(): " << test.empty() << "  size(): " << test.size() << "  max_size(): " << test.max_size() << endl;

        cout << "*************************after push_back****************************\n";
        test.push_back(1);
        cout << "empty(): " << test.empty() << "  size(): " << test.size() << "  max_size(): " << test.max_size() << endl;

        cout << "*************************after resize(5)****************************\n";
        test.resize(5);
        cout << "empty(): " << test.empty() << "  size(): " << test.size() << "  max_size(): " << test.max_size() << endl;

        cout << "*************************after shrink_to_fit****************************\n";
        test.shrink_to_fit();
        cout << "empty(): " << test.empty() << "  size(): " << test.size() << "  max_size(): " << test.max_size() << endl;

}

结果：

*************************after init****************************
empty(): 1  size(): 0  max_size(): 2305843009213693951
*************************after push_back****************************
empty(): 0  size(): 1  max_size(): 2305843009213693951
*************************after resize(5)****************************
empty(): 0  size(): 5  max_size(): 2305843009213693951
*************************after shrink_to_fit****************************
empty(): 0  size(): 5  max_size(): 2305843009213693951

3.deque构造

函数	功能
deque()	默认构造函数，构造一个空容器
deque(size_t n)	构造具有n个默认值的容器
deque(size_t n, const T& value)	构造具有n个值为value的容器
deque(first, last)	构造拥有范围 [first, last) 内容的容器
deque( const deque& other )	拷贝构造函数，构造一个拥有other内容的容器
deque( deque&& other )	移动构造函数，用移动语义构造拥有other内容的容器，移动后other为empty()
deque( std::initializer_list init）	构造拥有initializer_list init内容的容器

void test_construct(){
        cout << "*************************deque()****************************\n";
        deque<int> test;
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;

        cout << "*************************deque(10)****************************\n";
        deque<int> test1(10);
        for(int i=0; i<test1.size(); ++i){
                cout << test1[i] << "  ";
        }
        cout << endl;

        cout << "*************************deque(10,2)****************************\n";
        deque<int> test2(10,2);
        for(int i=0; i<test2.size(); ++i){
                cout << test2[i] << "  ";
        }
        cout << endl;

        cout << "*************************deque(test2.begin(), test2.end())****************************\n";
        deque<int> test3(test2.begin(), test2.end());
        for(int i=0; i<test3.size(); ++i){
                cout << test3[i] << "  ";
        }
        cout << endl;

        cout << "*************************deque(test2)****************************\n";
        deque<int> test4(test2);
        for(int i=0; i<test4.size(); ++i){
                cout << test4[i] << "  ";
        }
        cout << endl;

        cout << "*************************deque(std::move(test2))****************************\n";
        deque<int> test5(std::move(test2));
        for(int i=0; i<test5.size(); ++i){
                cout << test5[i] << "  ";
        }
        cout << endl;

        cout << "*************************deque{1,2,3,4,5}****************************\n";
        deque<int> test6{1,2,3,4,5};
        for(int i=0; i<test6.size(); ++i){
                cout << test6[i] << "  ";
        }
        cout << endl;

*************************deque()****************************

*************************deque(10)****************************
0  0  0  0  0  0  0  0  0  0  
*************************deque(10,2)****************************
2  2  2  2  2  2  2  2  2  2  
*************************deque(test2.begin(), test2.end())****************************
2  2  2  2  2  2  2  2  2  2  
*************************deque(test2)****************************
2  2  2  2  2  2  2  2  2  2  
*************************deque(std::move(test2))****************************
2  2  2  2  2  2  2  2  2  2  
*************************deque{1,2,3,4,5}****************************
1  2  3  4  5 

4.deque元素访问

函数	功能
at()	访问指定元素，同时进行越界检查
operator[]	访问指定元素
front()	访问第一个元素
back()	访问最后一个元素

void test_access(){
        deque<int>test{1,2,3,4,5};
        cout<< "at(2):" << test.at(2) << "  [3]:"<< test[3] << "  front:" << test.front() << "  back:" << test.back() << endl;

}

at(2):3  [3]:4  front:1  back:5

5.deque元素修改

函数	功能
push_back(const T& value)	在尾部插入新元素value
push_front(const T& value)	在头部插入新元素value
insert(iterator pos, const T& value)	在pos前插入元素value
insert(iterator pos, size_t n, const T& value)	在pos前插入n个元素value
insert(iterator pos, iterator first, iterator last)	在pos前插入来自范围 [first, last)的元素
erase(iterator pos)	移除pos处的元素
erase(iterator first, iterator last)	移除范围 [first, last) 的元素
emplace_back(Args&&… args)	在容器尾部就地构造元素
emplace_front(Args&&… args)	在容器头部就地构造元素
pop_back()	删除尾部元素
pop_front()	删除头部元素
swap(deque& other)	将内容与other交换。不在单个元素上调用任何移动、复制或交换操作
clear()	清除所有元素

void test_modifier(){
        deque<int>test;
        cout << "*************************push_back(1)****************************\n";
        test.push_back(1);
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;

        cout << "*************************push_front(2)****************************\n";
        test.push_front(2);
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;

        cout << "*************************insert(test.begin(),2)****************************\n";
        test.insert(test.begin(), 2);
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;

        cout << "*************************insert(test.begin(),3,4)****************************\n";
        test.insert(test.begin(), 3, 4);
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;

        cout << "*************************insert(test.begin(),test2.begin(),test2.end())****************************\n";
        deque<int>test2{1,2,3,4,5};
        test.insert(test.begin(), test2.begin(), test2.end());
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;
        
        cout << "*************************erase(test.begin())****************************\n";
        test.erase(test.begin());
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;

        cout << "*************************erase(test.begin(),test.begin()+2)****************************\n";
        test.erase(test.begin(), test.begin()+2);
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;


        cout << "*************************emplace_back****************************\n";
        class Book{
        public:
                Book(const std::string& name):m_name(name){}
                inline std::string getName(){return m_name;}
        private:
                std::string m_name;
        };
        deque<Book> test_book;
        test_book.emplace_back("C++ Primer");
        for(int i=0; i<test_book.size(); ++i){
                cout << test_book[i].getName() << "  ";
        }
        cout << endl;

        cout << "*************************emplace_front****************************\n";
        test_book.emplace_front("Effective C++");
        for(int i=0; i<test_book.size(); ++i){
                cout << test_book[i].getName() << "  ";
        }
        cout << endl;
        
        cout << "*************************pop_back()****************************\n";
        test.pop_back();
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;

        cout << "*************************pop_front()****************************\n";
        test.pop_front();
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;

        cout << "*************************test.swap(test2)****************************\n";
        test.swap(test2);
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;

        cout << "*************************clear()****************************\n";
        test.clear();
        for(int i=0; i<test.size(); ++i){
                cout << test[i] << "  ";
        }
        cout << endl;

*************************push_back(1)****************************
1  
*************************push_front(2)****************************
1  2  
*************************insert(test.begin(),2)****************************
2  1  2  
*************************insert(test.begin(),3,4)****************************
4  4  4  2  1  2  
*************************insert(test.begin(),test2.begin(),test2.end())****************************
1  2  3  4  5  4  4  4  2  1  2  
*************************erase(test.begin())****************************
2  3  4  5  4  4  4  2  1  2  
*************************erase(test.begin(),test.begin()+2)****************************
4  5  4  4  4  2  1  2  
*************************emplace_back****************************
C++ Primer  
*************************emplace_front****************************
Effective C++  C++ Primer  
*************************pop_back()****************************
4  5  4  4  4  2  1  
*************************pop_front()****************************
5  4  4  4  2  1  
*************************test.swap(test2)****************************
1  2  3  4  5  
*************************clear()****************************