std::list

最新推荐文章于 2023-03-17 17:30:06 发布
最新推荐文章于 2023-03-17 17:30:06 发布
阅读量350 收藏
点赞数 1
分类专栏： C/C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TimerSea/article/details/127991948
版权

std::list

介绍

成员函数

非成员函数

介绍

// list 模板定义
template<class T, class Allocator = std::allocator<T>> class list;

namespace pmr {
    template< class T >
    using list = std::list<T, std::pmr::polymorphic_allocator<T>>;
}
  • std::list 介绍摘选自 cppreference.com 中文网 std::list 介绍
  • std::list 是支持常数时间从容器任何位置插入和移除元素的容器
  • 不支持快速随机访问。它通常实现为双向链表
  • 与 std::forward_list 相比，此容器提供双向迭代但在空间上效率稍低
  • 在 list 内或在数个 list 间添加、移除和移动元素不会是迭代器或引用失效
  • 迭代器只有在对应元素被删除时才会失效

成员函数

构造析构
#include <QCoreApplication>
#include <iostream>
#include <list>
#include <string>

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  auto Print = [](const std::string &msg, const std::list<int> &deq) { // 打印
    std::cout << msg << " : ";
    for (int val : deq)
      std::cout << val << "\t";

    std::cout << "\n";
  };

  using list_int = std::list<int>; // 声明整型列表类型

  list_int test{10, 20, 30, 40, 50}; // 测试数据
  Print("test", test);

  list_int l1; // 默认构造函数
  Print("l1", l1);

  std::allocator<int> alloc;
  list_int l2(alloc); // 设置分配器
  Print("l2", l2);

  list_int l3(10, -1, alloc); // 设置数量，值，分配器
  Print("l3", l3);

  list_int l4(10); // 设置数量
  Print("l4", l4);

  list_int l5(test.begin(), test.end(), alloc); // 使用迭代器初始化容器
  Print("l5", l5);

  list_int l6(l5); // 使用列表初始化
  Print("l6", l6);

  list_int l7(l6, alloc); // 使用列表初始化，指定分配器
  Print("l7", l7);

  list_int l8(std::move(l7)); // 使用移动构造
  Print("l8", l8);

  list_int l9(std::move(l8), alloc); // 使用移动构造，指定分配器
  Print("l9", l9);

  list_int l10{1, 2, 3, 4, 5, 6, 7, 8, 9}; // 使用初始化列表构造
  Print("l10", l10);

  std::initializer_list<int> lt{1, 2, 3, 4, 5, 6, 7, 8, 9};
  list_int l11(lt); // 使用初始化列表构造
  Print("l11", l11);
  
  list_int l12 = test; // 使用operator = 赋值，也可创建后使用 assign 函数赋值
  Print("l12", l12);
  // 析构函数默认
  return 0; // a.exec();
}

输出结果：
test : 10 20 30 40 50
l1 :
l2 :
l3 : -1 -1 -1 -1 -1 -1 -1 -1 -1 -1
l4 : 0 0 0 0 0 0 0 0 0 0
l5 : 10 20 30 40 50
l6 : 10 20 30 40 50
l7 : 10 20 30 40 50
l8 : 10 20 30 40 50
l9 : 10 20 30 40 50
l10 : 1 2 3 4 5 6 7 8 9
l11 : 1 2 3 4 5 6 7 8 9
l12 : 10 20 30 40 50

元素访问
int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  auto Print = [](const std::string &msg, const std::list<int> &deq) { // 打印
    std::cout << msg << " : ";
    for (int val : deq)
      std::cout << val << "\t";

    std::cout << "\n";
  };

  using list_int = std::list<int>; // 声明整型列表类型

  list_int test{10, 20, 30, 40, 50}; // 测试数据
  Print("test", test);

  std::cout << "index 0 : " << test.front() << std::endl;
  std::cout << "index 0 : " << test.front() << std::endl;
  std::cout << "index 4 : " << test.back() << std::endl;
  std::cout << "index 4 : " << test.back() << std::endl;

  return 0; // a.exec();
}

输出结果：
test : 10 20 30 40 50
index 0 : 10
index 0 : 10
index 4 : 50
index 4 : 50

迭代器
int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using list_int = std::list<int>; // 声明整型列表类型

  list_int test{10, 20, 30, 40, 50};      // 测试数据
  list_int::iterator iter = test.begin(); // 返回指向起始的迭代器
  for (; iter != test.end(); iter++) {
    std::cout << *iter << "\t";
  }
  std::cout << "\n";

  list_int::const_iterator citer = test.begin(); // 返回指向起始的迭代器，const
  for (; citer != test.end(); citer++) {
    std::cout << *citer << "\t";
  }
  std::cout << "\n";

  list_int::reverse_iterator riter = test.rbegin(); // 返回指向末尾的逆向迭代器
  for (; riter != test.rend(); riter++) {
    std::cout << *riter << "\t";
  }
  std::cout << "\n";

  list_int::const_reverse_iterator criter =
      test.crbegin(); // 返回指向末尾的 const 逆向迭代器，const
  for (; criter != test.crend(); criter++) {
    std::cout << *criter << "\t";
  }
  std::cout << "\n";

  return 0; // a.exec();
}

输出结果：
10 20 30 40 50
10 20 30 40 50
50 40 30 20 10
50 40 30 20 10

容量
int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  using list_int = std::list<int>;   // 声明整型列表类型
  list_int test{10, 20, 30, 40, 50}; // 测试数据

  std::cout << std::boolalpha << "test.empty : " << test.empty()
            << "\n"; // 检查容器是否为空
  std::cout << std::boolalpha << "test.size : " << test.size()
            << "\n"; // 返回容纳的元素数
  std::cout << std::boolalpha << "test.max_size : " << test.max_size()
            << "\n";   // 返回可容纳的最大元素数，和平台有关

  return 0; // a.exec();
}

输出结果：
test.empty : false
test.size : 5
test.max_size : 768614336404564650

修改器
int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  auto Print = [](const std::string &msg, const std::list<int> &deq) { // 打印
    std::cout << msg << " : ";
    for (int val : deq)
      std::cout << val << "\t";

    std::cout << "\n";
  };

  using list_int = std::list<int>;   // 声明整型列表类型
  list_int test{10, 20, 30, 40, 50}; // 测试数据
  Print("test", test);
  test.clear(); //清除内容
  Print("test", test);

  test.insert(test.begin(), 10); //  插入元素
  Print("test", test);

  test.emplace(test.begin(), 20); //原位构造元素
  Print("test", test);

  test.erase(test.begin()); //擦除元素
  Print("test", test);

  test.push_back(30); // 将元素添加到容器末尾
  Print("test", test);

  test.emplace_back(40); // 在容器末尾就地构造元素
  Print("test", test);

  test.pop_back(); // 移除末元素
  Print("test", test);

  test.push_front(50); //插入元素到容器起始
  Print("test", test);

  test.emplace_front(60); //在容器头部原位构造元素
  Print("test", test);

  test.pop_front(); // 移除首元素
  Print("test", test);

  test.resize(10); // 改变容器中可存储元素的个数
  Print("test", test);

  list_int l1;
  l1.swap(test); // 交换内容
  Print("test", test);
  Print("l1", l1);

  return 0; // a.exec();
}

输出结果：
test : 10 20 30 40 50
test :
test : 10
test : 20 10
test : 10
test : 10 30
test : 10 30 40
test : 10 30
test : 50 10 30
test : 60 50 10 30
test : 50 10 30
test : 50 10 30 0 0 0 0 0 0 0
test :
l1 : 50 10 30 0 0 0 0 0 0 0

操作
int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  auto Print = [](const std::string &msg, const std::list<int> &deq) { // 打印
    std::cout << msg << " : ";
    for (int val : deq)
      std::cout << val << "\t";

    std::cout << "\n";
  };

  using list_int = std::list<int>;   // 声明整型列表类型
  list_int l1{10, 20, 30, 40, 50};   // 测试数据
  list_int l2{50, 80, 90, 100, 110}; // 测试数据
  Print("l1", l1);
  Print("l2", l2);

  l1.merge(l2); // 合并二个已排序列表
  Print("l1", l1);
  Print("l2", l2);

  list_int l3{50, 90, 150};
  l1.splice(l1.end(), std::move(l3), l3.begin(),
            l3.end()); // 从另一个list中移动元素
  Print("l1", l1);

  l1.remove(100);
  Print("l1", l1);

  l1.remove_if(
      [&](int o) -> bool { return o > 100; }); // 移除满足特定标准的元素
  Print("l1", l1);

  l1.reverse(); // 将该链表的所有元素的顺序反转
  Print("l1", l1);

  l1.unique(); // 删除连续的重复元素
  Print("l1", l1);

  l1.sort(); // 对元素进行排序
  Print("l1", l1);

  return 0; // a.exec();
}

输出结果：
l1 : 10 20 30 40 50
l2 : 50 80 90 100 110
l1 : 10 20 30 40 50 50 80 90 100 110
l2 :
l1 : 10 20 30 40 50 50 80 90 100 110 50 90 150
l1 : 10 20 30 40 50 50 80 90 110 50 90 150
l1 : 10 20 30 40 50 50 80 90 50 90
l1 : 90 50 90 80 50 50 40 30 20 10
l1 : 90 50 90 80 50 40 30 20 10
l1 : 10 20 30 40 50 50 80 90 90

非成员函数

int main(int argc, char *argv[]) {
  QCoreApplication a(argc, argv);

  auto Print = [](const std::string &msg, const std::list<int> &deq) { // 打印
    std::cout << msg << " : ";
    for (int val : deq)
      std::cout << val << "\t";

    std::cout << "\n";
  };

  using list_int = std::list<int>; // 声明整型列表类型
  list_int l1{1, 2, 3, 4, 5};      // 初始化列表构造函数
  list_int l2{1, 2, 3, 4, 6};

  std::cout.setf(std::ios::boolalpha);
  std::cout << "l1 == l2 : " << (l1 == l2) << std::endl;
  std::cout << "l1 != l2 : " << (l1 != l2) << std::endl;
  std::cout << "l1 > l2 : " << (l1 > l2) << std::endl;
  std::cout << "l1 >= l2 : " << (l1 >= l2) << std::endl;
  std::cout << "l1 < l2 : " << (l1 < l2) << std::endl;
  std::cout << "l1 <= l2 : " << (l1 <= l2) << std::endl;
  std::cout.unsetf(std::ios::boolalpha);
  // c++20 废弃以上操作符重载，提供三路运算符 operator <=> ()

  Print("l1", l1);
  Print("l2", l2);
  std::swap(l1, l2);
  Print("l1", l1);
  Print("l2", l2);

  return 0; // a.exec();
}

输出结果：
l1 == l2 : false
l1 != l2 : true
l1 > l2 : false
l1 >= l2 : false
l1 < l2 : true
l1 <= l2 : true
l1 : 1 2 3 4 5
l2 : 1 2 3 4 6
l1 : 1 2 3 4 6
l2 : 1 2 3 4 5

起始

无夜_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL-list的使用 详细说明
来信
12-09 1488
listlist是一个具有头结点的双向循环链表，结构较为复杂，但是非常高效。 现在我创建一个list对象 首先需要包头文件：#include <list>std::list<int> l1;这个例子中，我实例化出了一个存int类型的对象。接下来我参考cpulscpuls.com，介绍接口的用法：一：数据操作：1.assign：①： void assign (size_type n, const
C++ 学习系列 -- std::list
最新发布
qq_33775774的博客
10-06 1982
list 是 c++ 中的序列式容器，其实现是双向链表，每个元素都有两个指针，分别指向前一个节点与后一个节点链表与数组都是计算机常用的内存数据结构，与数组连续内存空间不一样的地方在于，链表的空间是不连续的，链表是将一块块不连续的内存串联起来使用。正是由于链表的内存不连续这一特点，所以不能像数组一样，可以根据位置随机的访问每个元素，而链表我们压根不知道每个元素的实际位置到底在哪块内存区域。查找某个元素需要遍历整个链表，直到找到目标元素位置，时间复杂度是 O(n)；
c++ std::list
肥猫王德福的博客
11-30 1116
重点总结 List是stl实现的双向链表，它允许快速的插入和删除 List一、pandas是什么？ 一、pandas是什么？
[转] C++ STL标准库： std::list使用介绍、用法详解
sroman的博客
03-01 3693
https://blog.csdn.net/u014779536/article/details/111301635
STL STD::list使用说明
热门推荐
lanyzh0909的专栏
05-15 5万+
stl list使用说明 使用标准的std::list进行容器数据处理时，操作比较底层。我们可以，减少引用标准MFC标准库，减少系统的大小，但同时也存在有不方便的操作之处，这里同大家分享一些使用心得......       在使用std::list::iterator链表遍历器进行访问 list     STL 中的list 就是一 双向链表，可高效
std::List类的遍历获得元素的操作二法
10-06
在C++标准库中，`std::list`是一种双链表容器，它提供了一种高效的方式来存储和操作序列数据。由于`std::list`不是随机访问容器，因此它不支持像数组那样的通过索引直接访问元素（如`[]`运算符）。但是，`std::list`...
自定义STL std :: allocator替换可提高性能
04-11
它是STL容器（如`std::vector`、`std::list`等）默认使用的内存分配器。它负责为容器中的对象分配和释放内存。`std::allocator`遵循了C++标准规定的内存分配接口，但它的实现通常是基于`new`和`delete`操作，这可能...
C++11中lambda、std::function和std:bind详解
08-31
这篇文主要关注三个核心概念：lambda表达式、std::function和std::bind。 **Lambda表达式**是C++11引入的一种内联匿名函数，它允许我们在需要的地方直接定义函数对象，而无需单独声明一个函数。Lambda表达式的语法...
std::list 使用
01-26
linux 下 std::list的使用
C++利用std::forward_list查找插入数据方法示例
08-29
在C++编程中，std::forward_list是一种单向链表容器，它在C++11标准库中被引入。forward_list的设计目标是为了提供一种高效、节省内存的序列容器，尤其适用于需要频繁插入和删除元素，但不需要快速随机访问的情况。...
C++ STL容器之list
hestyle的博客
05-02 1113
C++ list 容器 定义于头文件 <list> 申明 template<class T, class Allocator = std::allocator<T> > class list; std::list 是支持常数时间从容器任何位置插入和移除元素的容器。不支持快速随机访问。它通常实现为双向链表。与 std::forward_list 相比，此容器提供...
C++——std::List
zy2317878的博客
01-25 5373
写在前面 这一篇博客系统学习一下C++中List类的相关函数。之所以要学习这个类，是由于LeetCode中做到了Linked List类，虽然在LeetCode中并没有使用到List类的相关函数，而是主要利用链表的数据结构来完成一些内容，或者说，就是从基础的数据结构来实现接下来要学习的一些链表类的函数，比如：插入，删除结点等等。这篇博客的风格内容与之前博客并无两异，所以主要目的还是对List类的...
STL——list详解
weixin_54209978的博客
03-17 4104
这是一片关于list的详细介绍，并模拟实现了一个list类，帮助您更深入地理解和使用STL
C/C++编程：STL list的使用
OceanStar的博客
08-10 1052
目录 list 构造 std::list::operator=、std::list::assign,allocator>,allocator> front、back begin、end、rbegin、rend empty、size、max_size、resize swap clear、erase emplace、emplace_front、push_back merge splice remove, remove_if reverse unique 比较..
STL中list详解
axiqia的专栏
01-13 4501
std::list Lists are sequence containers that allow constant time insert and erase operations anywhere within the sequence, and iteration in both directions. 实际上,list容器就是一个双向链表,可以高效地进行插入删除元素。 stdli
C/C++ — STL中List用法
HiroGuo 的博客
01-21 4626
C/C++ — STL中List用法List 简述List 的使用增加和插入元素List删除元素List排序及合并 List 简述 std::list C++ 容器模版，T类型的双向链表。有序、可以在任意位置插入或删除。无法通过位置来访问元素，必须逐个遍历，可以通过开始元素或者最后一个元素遍历。 List 的使用 生成一个空的list容器： std::list &amp;lt;std::string&amp;gt...
放弃了std::list，自己实现了一个简单的list
鱼塘鱼汤的专栏
03-16 617
原因 在项目中前人使用了std::list来做一个队列式，支持头或者尾的push操作。使用场景是视频的录制： 生产者：从摄像头采集数据，然后push_front到队列头，如果超过了最大限制，则pop_back队列尾的元素，实现丢帧操作 消费者：从队列里面back拿到桢，然后pop_back删除末尾桢。 所有的list的操作均加入了互斥锁。理论上应该是没有多线程访问的问题的。然而在线上表现却...
STL 简单 list 的实现
chengonghao的博客
05-18 2213
相较于vector的连续线性空间，list就显得复杂许多，它的好处是每次插入或删除一个元素，就配置或释放一个元素空间。因此，list对于空间的运用有绝对的精准，一点不浪费。Vector的插入操作可能造成内存的重新配置，但是List不会。          List不再能够像vector一样以普通指针作为迭代器，因为其节点不保证在存储空间在连续存在。由于list是一个双向链表，迭代器必须具有前移、
std::list与std::sort 使用std::list sort排序
07-28
`std::list` 是一个双向链表容器，它的元素不是连续存储的，因此不能像 `std::vector` 一样直接使用 `std::sort` 进行排序。不过，`std::list` 自带一个成员函数 `sort()` 用于对链表进行排序。 以下是使用 `std::...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值