• 【C++】———list容器

    前言

    1.list容器简单来说其实就是之前的链表结构。

    2.这里的list用的是双向带头结点的循环链表。

    目录

    前言

    一  构造函数

    1.1   list ();

    1.2    list (size_type n, const value_type& val = value_type() );

    1.3   list (InputIterator first, InputIterator last );

    1.4   list (const list& x);

    二  析构函数 

    ~list();

    三  赋值运算符重载

    list& operator= (const list& x);

     四  迭代器

     4.1  正向迭代器

    4.2  反向迭代器

    ​ 五 容量函数

    5.1  bool empty() const;

    5.2  size_type size() const;

    六  修改器

    6.1  assign（）

     6.2  插入数据和删除数据

    5.insert ()

    6.erase()

    6.3  void resize (size_type n, value_type val = value_type());

    6.4 void clear();

     七  操作

    7.1  splice（）

     7.2 unique（）

    总结

    一  构造函数

    1.1   list ();

    括号里面是一个适配器。

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

     构造一个没有元素的空容器。 

    1.2    list (size_type n, const value_type& val = value_type() );

    填充构造函数

    构造一个包含n个元素的容器。每个元素都是val的一个副本。

    1.3   list (InputIterator first, InputIterator last );

    里面的InputIterator代表的是迭代器的类型。

    范围构造函数

    构造一个具有与范围[first,last)一样多元素的容器，其中每个元素都按照相同的顺序由该范围内的相应元素构造。

    1.4   list (const list& x);

    拷贝构造函数

    按照相同顺序构造一个容器，其中包含x中每个元素的副本。

     测试案例：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. // constructing lists
    3. #include 
    4. #include 
    5. using namespace std;
    6. int main()
    7. {
    8.    
    9.     std::list<int> first;                                // 一个空列表
    10.     std::list<int> second(4, 100);                       // 4个100的值
    11.     std::list<int> third(second.begin(), second.end());  // 迭代器用second的值初始化third
    12.     std::list<int> fourth(third);                       // third的一个拷贝
    13.  
    14.     // 这里也可以用数组去迭代初始化
    15.     int myints[] = { 16,2,77,29 };
    16.     std::list<int> fifth(myints, myints + sizeof(myints) / sizeof(int));
    17.  
    18.     cout << "first:";
    19.     for (std::list<int>::iterator it = first.begin(); it != first.end(); it++)
    20.         std::cout << *it << ' ';
    21.     cout << endl;
    22.  
    23.  
    24.     cout << "second:";
    25.     for (std::list<int>::iterator it = second.begin(); it != second.end(); it++)
    26.         std::cout << *it << ' ';
    27.     cout << endl;
    28.  
    29.  
    30.     cout << "third:";
    31.     for (std::list<int>::iterator it = third.begin(); it != third.end(); it++)
    32.         std::cout << *it << ' ';
    33.     cout << endl;
    34.  
    35.  
    36.     cout << "fourth:";
    37.     for (std::list<int>::iterator it = fourth.begin(); it != fourth.end(); it++)
    38.         std::cout << *it << ' ';
    39.     cout << endl;
    40.  
    41.     std::cout << "fifth: ";
    42.     for (std::list<int>::iterator it = fifth.begin(); it != fifth.end(); it++)
    43.         std::cout << *it << ' ';
    44.     std::cout << '\n';
    45.  
    46.     return 0;
    47. }

    ​

    二  析构函数 

    ~list();

    把所有容器元素都销毁，并且把分配器的空间释放。

    三  赋值运算符重载

    list& operator= (const list& x);

    测试用例：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. // assignment operator with lists
    3. #include 
    4. #include 
    5. using namespace std;
    6. int main()
    7. {
    8. 	list<int> first(3);      // 初始化为3
    9. 	list<int> second(5);     // 初始化为5
    10.  
    11. 	second = first;//赋值
    12. 	first = list<int>();//把一个匿名对象赋值给first
    13.  
    14. 	cout << "Size of first: " << int(first.size()) << endl;
    15. 	cout << "Size of second: " << int(second.size()) << endl;
    16. 	return 0;
    17. }

    ​ 

     四  迭代器

    迭代器分为正向迭代器和反向迭代器

     4.1  正向迭代器

    iterator begin()   

    iterator end()

    测试用例

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. // list::begin
    3. #include 
    4. #include 
    5. using namespace std;
    6. int main()
    7. {
    8.     int myints[] = { 75,23,65,42,13 };
    9.     list<int> mylist(myints, myints + 5);
    10.  
    11.     std::cout << "mylist contains:";
    12.     for (list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
    13.         cout << ' ' << *it;
    14.  
    15.     cout <
    16.  
    17.     return 0;
    18. }

    ​

    4.2  反向迭代器

    reverse_iterator rbegin();

    reverse_iterator rend();

    测试用例

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. // list::rbegin/rend
    3. #include 
    4. #include 
    5. using namespace std;
    6. int main()
    7. {
    8.     list<int> mylist;
    9.     for (int i = 1; i <= 5; i++)
    10.     {
    11.         mylist.push_back(i);
    12.     }
    13.  
    14.     cout << "mylist backwards:";
    15.     for (list<int>::reverse_iterator rit = mylist.rbegin(); rit != mylist.rend(); ++rit)
    16.         cout << ' ' << *rit;
    17.  
    18.     cout << endl;
    19.  
    20.     return 0;
    21. }

    ​ 
    五 容量函数

    5.1  bool empty() const;
    1. // list::empty
    2. #include 
    3. #include 
    4.  
    5. int main()
    6. {
    7.     std::list<int> mylist;
    8.     int sum(0);
    9.  
    10.     for (int i = 1; i <= 10; ++i) mylist.push_back(i);
    11.  
    12.     while (!mylist.empty())
    13.     {
    14.         sum += mylist.front();
    15.         mylist.pop_front();
    16.     }
    17.  
    18.     std::cout << "total: " << sum << '\n';
    19.  
    20.     return 0;
    21. }

    为了方便测试，所以这里用了没有说明的函数。

    ​

    5.2  size_type size() const;
    1. // list::size
    2. #include 
    3. #include 
    4.  
    5. int main()
    6. {
    7. 	std::list<int> myints;
    8. 	std::cout << "0. size: " << myints.size() << '\n';
    9.  
    10. 	for (int i = 0; i < 10; i++) myints.push_back(i);
    11. 	std::cout << "1. size: " << myints.size() << '\n';
    12.  
    13. 	myints.insert(myints.begin(), 10, 100);
    14. 	std::cout << "2. size: " << myints.size() << '\n';
    15.  
    16. 	myints.pop_back();
    17. 	std::cout << "3. size: " << myints.size() << '\n';
    18.  
    19. 	return 0;
    20. }

     ​

    六  修改器

    6.1  assign（）

    替换内容，并相应的修改大小

    void assign (InputIterator first, InputIterator last);

    void assign (size_type n, const value_type& val);

    1. / list::assign
    2. #include 
    3. #include 
    4.  
    5. int main ()
    6. {
    7.   std::list<int> first;
    8.   std::list<int> second;
    9.  
    10.   first.assign (7,100);                    //设置7个100的值
    11.  
    12.   second.assign (first.begin(),first.end());//用这7个值去替代second里面的内容
    13.  
    14.   int myints[]={1776,7,4};
    15.   first.assign (myints,myints+3);            //用数组里面的内容去替代
    16.  
    17.   std::cout << "Size of first: " << int (first.size()) << '\n';
    18.   std::cout << "Size of second: " << int (second.size()) << '\n';
    19.   return 0;
    20. }

     6.2  插入数据和删除数据

    1.void push_front (const value_type& val);//头插

    2.void pop_front();//头删

    3.void push_back (const value_type& val);//尾插

    4.void pop_back();//尾删

    这些操作函数在上面的测试中都有演示

    1.  
    2. #include 
    3. #include 
    4.  
    5. int main()
    6. {
    7.     std::list<int> mylist;
    8.     int sum(0);
    9.     mylist.push_back(100);//尾插
    10.     mylist.push_back(200);
    11.     mylist.push_back(300);
    12.     mylist.push_front(400);//头插
    13.     mylist.pop_front();
    14.     while (!mylist.empty())
    15.     {
    16.         sum += mylist.back();
    17.         mylist.pop_back();//尾删
    18.     }
    19.  
    20.     std::cout << "The elements of mylist summed " << sum << '\n';
    21.  
    22.     return 0;
    23. }

    5.insert ()

     iterator insert (iterator position, const value_type& val);//插入一个数据

    void insert (iterator position, size_type n, const value_type& val);//插入n个数据

    1. // inserting into a list
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. int main()
    7. {
    8.     std::list<int> mylist;
    9.     std::list<int>::iterator it;
    10.  
    11.    
    12.     for (int i = 1; i <= 5; ++i) mylist.push_back(i); // 1 2 3 4 5
    13.  
    14.     it = mylist.begin();
    15.     ++it;       
    16.     mylist.insert(it, 10);                        // 1 10 2 3 4 5
    17.  
    18.                         
    19.     mylist.insert(it, 2, 20);                      // 1 10 20 20 2 3 4 5
    20.  
    21.     --it;       // it 指向第二个20            ^
    22.  
    23.     std::vector<int> myvector(2, 30);
    24.     mylist.insert(it, myvector.begin(), myvector.end());
    25.     // 1 10 20 30 30 20 2 3 4 5
    26.     //               ^
    27.     std::cout << "mylist contains:";
    28.     for (it = mylist.begin(); it != mylist.end(); ++it)
    29.         std::cout << ' ' << *it;
    30.     std::cout << '\n';
    31.  
    32.     return 0;
    33. }

     

    6.erase()

    iterator erase (iterator position);//删除一个数据

    iterator erase (iterator first, iterator last);//删除迭代器区间的数据

    1. // erasing from list
    2. #include 
    3. #include 
    4.  
    5. int main()
    6. {
    7.     std::list<int> mylist;
    8.     std::list<int>::iterator it1, it2;
    9.  
    10.     // set some values:
    11.     for (int i = 1; i < 10; ++i) mylist.push_back(i * 10);
    12.  
    13.                                 // 10 20 30 40 50 60 70 80 90
    14.     it1 = it2 = mylist.begin(); // ^^
    15.     advance(it2, 6);            // ^                 ^
    16.     ++it1;                      //    ^              ^
    17.  
    18.     it1 = mylist.erase(it1);   // 10 30 40 50 60 70 80 90
    19.                                //    ^           ^
    20.  
    21.     it2 = mylist.erase(it2);   // 10 30 40 50 60 80 90
    22.                                //    ^           ^
    23.  
    24.     ++it1;                      //       ^        ^
    25.     --it2;                      //       ^     ^
    26.  
    27.     mylist.erase(it1, it2);     // 10 30 60 80 90
    28.                                 //        ^
    29.  
    30.     std::cout << "mylist contains:";
    31.     for (it1 = mylist.begin(); it1 != mylist.end(); ++it1)
    32.         std::cout << ' ' << *it1;
    33.     std::cout << '\n';
    34.  
    35.     return 0;
    36. }

    这里的advance起到一个推动迭代器的功能，

    这里删除元素的时候需要用一个变量来接收是为了防止迭代器失效的问题。

    6.3  void resize (size_type n, value_type val = value_type());

    1.如果n<当前容量大小，那么会把容量缩到n,并且删除多余的元素

    2.如果n>当前容量，会把容量扩到n,多余的元素会以val值来填充

    1. // resizing list
    2. #include 
    3. #include 
    4.  
    5. int main()
    6. {
    7.     std::list<int> mylist;
    8.  
    9.     // set some initial content:
    10.     for (int i = 1; i < 10; ++i) mylist.push_back(i);
    11.  
    12.     mylist.resize(5);
    13.     mylist.resize(8, 100);
    14.     mylist.resize(12);
    15.  
    16.     std::cout << "mylist contains:";
    17.     for (std::list<int>::iterator it = mylist.begin(); it != mylist.end(); ++it)
    18.         std::cout << ' ' << *it;
    19.  
    20.     std::cout << '\n';
    21.  
    22.     return 0;
    23. }

     

    6.4 void clear();
    1. // clearing lists
    2. #include 
    3. #include 
    4.  
    5. int main()
    6. {
    7.     std::list<int> mylist;
    8.     std::list<int>::iterator it;
    9.  
    10.     mylist.push_back(100);
    11.     mylist.push_back(200);
    12.     mylist.push_back(300);
    13.  
    14.     std::cout << "mylist contains:";
    15.     for (it = mylist.begin(); it != mylist.end(); ++it)
    16.         std::cout << ' ' << *it;
    17.     std::cout << '\n';
    18.  
    19.     mylist.clear();//清除
    20.     mylist.push_back(1101);
    21.     mylist.push_back(2202);
    22.  
    23.     std::cout << "mylist contains:";
    24.     for (it = mylist.begin(); it != mylist.end(); ++it)
    25.         std::cout << ' ' << *it;
    26.     std::cout << '\n';
    27.  
    28.     return 0;
    29. }

     七  操作

    7.1  splice（）

    移动后，原容器的元素会被删除掉

    void splice (iterator pos, list& x);//将元素从x转移到容器中，并将它们插入到指定位置。

    void splice (iterator pos, list& x, iterator i);//移动指定的元素

    void splice (iterator pos, list& x, iterator first, iterator last);//移动迭代区间的元素到容器里面

    1. // splicing lists
    2. #include 
    3. #include 
    4.  
    5. int main()
    6. {
    7.     std::list<int> mylist1, mylist2;
    8.     std::list<int>::iterator it;
    9.  
    10.     
    11.     for (int i = 1; i <= 4; ++i)
    12.         mylist1.push_back(i);      // mylist1: 1 2 3 4
    13.  
    14.     for (int i = 1; i <= 3; ++i)
    15.         mylist2.push_back(i * 10);   // mylist2: 10 20 30
    16.  
    17.     it = mylist1.begin();
    18.     ++it;                         // points to 2
    19.  
    20.     mylist1.splice(it, mylist2); // mylist1: 1 10 20 30 2 3 4
    21.     // mylist2 (empty)
    22.     // it 依然指向2
    23.  
    24.     mylist2.splice(mylist2.begin(), mylist1, it);
    25.     // mylist1: 1 10 20 30 3 4
    26.     // mylist2: 2
    27.     // it现在已经失效了
    28.     it = mylist1.begin();//重新赋值
    29.     std::advance(it, 3);           // it 指向30
    30.  
    31.     mylist1.splice(mylist1.begin(), mylist1, it, mylist1.end());
    32.     // mylist1: 30 3 4 1 10 20
    33.  
    34.     std::cout << "mylist1 contains:";
    35.     for (it = mylist1.begin(); it != mylist1.end(); ++it)
    36.         std::cout << ' ' << *it;
    37.     std::cout << '\n';
    38.  
    39.     std::cout << "mylist2 contains:";
    40.     for (it = mylist2.begin(); it != mylist2.end(); ++it)
    41.         std::cout << ' ' << *it;
    42.     std::cout << '\n';
    43.  
    44.     return 0;
    45. }

     7.2 unique（）

    相当于是一个去重的函数

    void unique();

    1. int main()
    2. {
    3. 	std::list<int> mylist1;
    4. 	std::list<int>::iterator it;
    5. 	mylist1.push_back(1);
    6. 	mylist1.push_back(1);
    7. 	mylist1.push_back(2);
    8. 	mylist1.push_back(2);
    9. 	mylist1.push_back(4);
    10. 	mylist1.push_back(4);
    11. 	mylist1.push_back(5);
    12. 	for (it = mylist1.begin(); it != mylist1.end(); it++)
    13. 	{
    14. 		std::cout <<" " << *it;
    15. 	}
    16. 	std::cout << '\n';
    17. 	mylist1.unique();
    18. 	for (it = mylist1.begin(); it != mylist1.end(); it++)
    19. 	{
    20. 		std::cout << " " << *it;
    21. 	}
    22. 	return 0;
    23. }

    但是对于另外一种情况，可能不是很明显，比如如果队列不是有序的，那么去重的效果就会差一点 

    所以这个并不能达到无忧无虑的状态，必要情况下需要自己排序

    总结

    以上就是list的全部内容了，可能还有一些函数没有说明，会放在list模拟实现里面说明，list和之前的vector的操作都是大差不差的，主要的区别在于底层的实现  🎉🎉

  • 相关阅读:
    vue面试题
    使用消息队列的方式实现进程间通信，输入quit时退出
    php农村生态游服务平台
    字符串数数——考虑循环节：1108T3
    Linux基本指令（下）——“Linux”
    面向对象-01我的世界
    嵌入式 Linux 入门（十、Linux 下的 C 编程）
    JDK8和JDK11使用Hotswap Agent在idea进行热部署
    window.open 打开后全屏
    c++桥接模式，中介者模式应用实现状态跳转
  • 原文地址：https://blog.csdn.net/m0_74092462/article/details/139377933