【C++】list的认识与使用

​​

list的认识与使用

• list的介绍
• list的使用
• • Member functions（成员函数）
  • • constuctor（构造函数）
    • destructor（析构函数）
    • operator=（赋值构造）
    • Iterators（迭代器）
    • • begin
      • end
      • rbegin
      • rend
      • Capacity（容量）
      • • empty
        • size
        • max_size
        • Element access（元素访问）
        • • front
          • back
          • Modifiers（修饰符）
          • • assign
            • push_front
            • pop_front
            • push_back
            • pop_back
            • insert
            • erase
            • swap
            • resize
            • clear
            • Operations（操作）
            • • reverse
              • sort
              • Non-member function overloads（非成员函数重载）
              • • relational operators (list)
                • swap (list)

                  list的介绍

                  ​​

                  • std::list
                  • template class list;

                    1.list是可以在常数范围内可以在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。

                    2.list的底层是双向链表结构，双向链表中的每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。

                    3.list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，比起更加简单高效。

                    4.与其他的序列式容器相比（array，vector，deque），list通常在任意位置进行插入，移除元素的执行效率更好。

                    5.与其他的序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置（比如头部或者尾部）迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息（对于存储类型较小元素的大list来说这可能是一个重要的因素）。

                    

                    list的使用

                    Member functions（成员函数）

                    constuctor（构造函数）

                    

                    • std::list::list
                    • 构造链表
                    • default (1)

                      explicit list (const allocator_type& alloc = allocator_type());

                      空容器构造函数（默认构造函数）

                      	list lt1;
                      

                      • fill (2)

                        explicit list (size_type n, const value_type& val = value_type(),

                        const allocator_type& alloc = allocator_type());

                        多参数构造函数

                        	list lt2(4, 100);
                        

                        • range (3)

                          template

                          list (InputIterator first, InputIterator last,

                          const allocator_type& alloc = allocator_type());

                          范围构造函数

                          	list lt3(lt2.begin(), lt2.end());
                          

                          • copy (4)

                            list (const list& x);

                            拷贝构造函数

                            	list lt4(lt3);
                            

                            destructor（析构函数）

                            

                            • std::list::~list
                            • ~list();
                            • list的析构函数

                              operator=（赋值构造）

                              

                              • std::list::operator=

                              • copy (1)

                                list& operator= (const list& x);

                              • 分配内容

                                	list lt1;
                                	list lt2(4, 100);
                                	lt1 = lt2;
                                

                                Iterators（迭代器）

                                begin

                                

                                • std::list::begin

                                • iterator begin();

                                • const_iterator begin() const;

                                • 返回指向开始的迭代器

                                  end

                                  

                                  • std::list::end
                                  • iterator end();
                                  • const_iterator end() const;
                                  • 返回指向结尾的迭代器

                                    	list lt(4, 100);
                                    	list::iterator it = lt.begin();
                                    	while (it != lt.end())
                                    	{
                                    		cout 
                                    		cout 
                                    		cout 
                                    		cout 
                                    		cout 
                                    		cout 
                                    		cout 
                                    		cout