std::forward_list

最新推荐文章于 2024-03-19 18:40:01 发布
最新推荐文章于 2024-03-19 18:40:01 发布
阅读量612 收藏 1
点赞数
分类专栏： C/C++ 文章标签： list 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TimerSea/article/details/127998333
版权

std::forward_list

介绍

成员函数

非成员函数

介绍

// forward_list 模板定义
template<class T, class Allocator = std::allocator<T>> class forward_list;	(C++11 起)
namespace pmr {
    template <class T>
    using forward_list = std::forward_list<T, std::pmr::polymorphic_allocator<T>>;
}	(C++17 起)
  • std::forward_list 介绍摘选自 cppreference.com 中文网 std::forward_list 介绍
  • std::forward_list 是支持从容器中的任何位置快速插入和移除元素的容器，不支持快速随机访问
  • 它实现为单链表，且实质上与其在 C 中实现相比无任何开销
  • 与 std::list 相比，此容器在不需要双向迭代时提供更有效地利用空间的存储
  • 在链表内或跨数个链表添加、移除和移动元素，不会非法化当前指代链表中其他元素的迭代器
  • 在从链表移除元素（通过 erase_after ）时，指代对应元素的迭代器或引用会被非法化

成员函数

构造析构
#include <QCoreApplication>
#include <algorithm>
#include <forward_list>
#include <iostream>
#include <string>

auto Print(const std::string &msg, const std::forward_list<int> &lst) {
  std::cout << msg << " : ";
  for (auto iter = lst.begin(); iter != lst.end(); ++iter) {
    std::cout << *iter << "\t";
  }
  std::cout << "\n";
}

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

  using list_int = std::forward_list<int>;
  list_int l1; //默认构造
  Print("l1", l1);

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

  list_int l3(5, -1, alloc); //设置元素数量，初始值，分配器
  Print("l3", l3);

  list_int l4(5); //设置元素数量
  Print("l4", l4);

  list_int l5(l3.begin(), l3.end()); //迭代器初始化
  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{0, 2, 4, 6, 8, 10}; //初始化列表
  Print("l10", l10);
  return 0; // a.exec();
}

输出结果：
l1 :
l2 :
l3 : -1 -1 -1 -1 -1
l4 : 0 0 0 0 0
l5 : -1 -1 -1 -1 -1
l6 : -1 -1 -1 -1 -1
l7 : -1 -1 -1 -1 -1
l8 : -1 -1 -1 -1 -1
l9 : -1 -1 -1 -1 -1
l10 : 0 2 4 6 8 10

元素访问
auto Print(const std::string &msg, const std::forward_list<int> &lst) {
  std::cout << msg << " : ";
  for (auto iter = lst.begin(); iter != lst.end(); ++iter) {
    std::cout << *iter << "\t";
  }
  std::cout << "\n";
}

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

  using list_int = std::forward_list<int>;
  list_int l1{1, 3, 5, 7, 9}; 
  Print("l1", l1);
  std::cout << "index 0 : " << l1.front() << std::endl; //访问第一个元素
  std::cout << "index 0 : " << l1.front() << std::endl; //访问第一个元素

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

输出结果：
l1 : 1 3 5 7 9
index 0 : 1
index 0 : 1

迭代器
auto Print(const std::string &msg, const std::forward_list<int> &lst) {
  std::cout << msg << " : ";
  for (auto iter = lst.begin(); iter != lst.end(); ++iter) {
    std::cout << *iter << "\t";
  }
  std::cout << "\n";
}

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

  using list_int = std::forward_list<int>;
  list_int l1{1, 3, 5, 7, 9}; 
  Print("l1", l1);

  //返回指向首元素前一元素的迭代器。此元素表现为占位符，试图访问它会导致未定义行为。仅有的使用情况是在函数
  // insert_after() 、 emplace_after() 、 erase_after() 、 splice_after()
  //和迭代器自增中：自增始前迭代器准确地给出与从 begin()/cbegin()
  //获得者相同的迭代器。
  list_int::iterator biter = l1.before_begin();
  list_int::const_iterator cbiter = l1.cbefore_begin();

  list_int::iterator iter = l1.begin();
  std::cout << "l1 : ";
  for (; iter != l1.end(); ++iter) {
    std::cout << *iter << "\t";
  }
  std::cout << "\n";

  list_int::const_iterator citer = l1.begin();
  std::cout << "l1 : ";
  for (; citer != l1.end(); ++citer) {
    std::cout << *citer << "\t";
  }
  std::cout << "\n";

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

输出结果：
l1 : 1 3 5 7 9
l1 : 1 3 5 7 9
l1 : 1 3 5 7 9

容量
auto Print(const std::string &msg, const std::forward_list<int> &lst) {
  std::cout << msg << " : ";
  for (auto iter = lst.begin(); iter != lst.end(); ++iter) {
    std::cout << *iter << "\t";
  }
  std::cout << "\n";
}

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

  using list_int = std::forward_list<int>;
  list_int l1{1, 3, 5, 7, 9};
  Print("l1", l1);

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

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

输出结果：
l1 : 1 3 5 7 9
test.empty : false
test.max_size : 1152921504606846975

修改器
auto Print(const std::string &msg, const std::forward_list<int> &lst) {
  std::cout << msg << " : ";
  for (auto iter = lst.begin(); iter != lst.end(); ++iter) {
    std::cout << *iter << "\t";
  }
  std::cout << "\n";
}

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

  using list_int = std::forward_list<int>;
  list_int l1{1, 3, 5, 7, 9};
  Print("l1", l1);

  l1.clear(); // 清除内容
  Print("l1", l1);

  l1.insert_after(l1.cbefore_begin(), 10); //在某个元素后插入新元素
  Print("l1", l1);

  l1.emplace_after(l1.cbefore_begin(), 20); //在元素后原位构造元素
  Print("l1", l1);
  l1.erase_after(l1.cbegin()); //擦除元素后的元素
  Print("l1", l1);
  l1.push_front(30); //插入元素到容器起始
  Print("l1", l1);
  l1.emplace_front(40); //在容器头部原位构造元素
  Print("l1", l1);
  l1.pop_front(); //移除首元素
  Print("l1", l1);
  l1.resize(10); //改变容器中可存储元素的个数
  Print("l1", l1);

  list_int l2{2, 4, 6, 8, 10};
  Print("l2", l2);
  l1.swap(l2); //交换内容
  Print("l1", l1);
  Print("l2", l2);

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

输出结果：
l1 : 1 3 5 7 9
l1 :
l1 : 10
l1 : 20 10
l1 : 20
l1 : 30 20
l1 : 40 30 20
l1 : 30 20
l1 : 30 20 0 0 0 0 0 0 0 0
l2 : 2 4 6 8 10
l1 : 2 4 6 8 10
l2 : 30 20 0 0 0 0 0 0 0 0

操作
auto Print(const std::string &msg, const std::forward_list<int> &lst) {
  std::cout << msg << " : ";
  for (auto iter = lst.begin(); iter != lst.end(); ++iter) {
    std::cout << *iter << "\t";
  }
  std::cout << "\n";
}

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

  using list_int = std::forward_list<int>;
  list_int l1{1, 3, 5, 7, 9};
  list_int l2{2, 4, 6, 8, 10};
  Print("l1", l1);
  Print("l2", l2);

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

  list_int l3{10, 20, 30};
  l1.splice_after(l1.before_begin(), l3); //从另一 forward_list 移动元素
  Print("l1", l1);

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

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

  list_int l4{2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 3, 3, 5};
  l4.unique(); //删除连续的重复元素
  Print("l4", l4);

  list_int l5{5, 6, 1, 2, 4};
  l5.sort(); //对元素进行排序
  Print("l5", l5);

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

输出结果：
l1 : 1 3 5 7 9
l2 : 2 4 6 8 10
l1 : 1 2 3 4 5 6 7 8 9 10
l2 :
l1 : 10 20 30 1 2 3 4 5 6 7 8 9 10
l1 : 10 30 1 2 3 4 5 6 7 8 9 10
l1 : 10 1 2 3 4 5 6 7 8 9 10
l1 : 10 9 8 7 6 5 4 3 2 1 10
l4 : 2 3 4 3 5
l5 : 1 2 4 5 6

非成员函数

auto Print(const std::string &msg, const std::forward_list<int> &lst) {
  std::cout << msg << " : ";
  for (auto iter = lst.begin(); iter != lst.end(); ++iter) {
    std::cout << *iter << "\t";
  }
  std::cout << "\n";
}

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

  using list_int = std::forward_list<int>;
  list_int l1{1, 3, 5, 7, 9};
  list_int l2{2, 4, 6, 8, 10};
  Print("l1", l1);
  Print("l2", l2);

  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 <=> ()

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

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

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

起始

无夜_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
forward_list
weixin_43117602的博客
02-07 1641
forward_list 容器具有和 list 容器相同的特性，即擅长在序列的任何位置进行插入元素或删除元素的操作，但对于访问存储的元素，没有其它容器（如 array、vector）的效率高。 另外，由于单链表没有双向链表那样灵活，因此相比 list 容器，forward_list 容器的功能受到了很多限制。比如，由于单链表只能从前向后遍历，而不支持反向遍历，因此 forward_list 容器只提供前向迭代器，而不是双向迭代器。这意味着，forward_list 容器不具有 rbegin()、rend()
上下定高 中间自适应_上下固定高，中间自适应
weixin_39822443的博客
12-20 187
自适应body{padding: 0;margin: 0; }/*在无内容的情况下也能显示出自适应元素需要两个条件：(所有元素的宽一致)1、父元素高度；1.1、已知了自适应元素(box2)上下元素的高，还需知道父元素的高，这样自适应元素才能算出自己的高；1.2、由于高度已经固定，如果超出高度，可使用overflow:scroll解决；2、使用绝对定位；2.1、使用了绝对定位，确定了元素相对于父元素...
C++11中std::forward_list单向链表的使用
网络资源是无限的
06-04 5594
C++11中std::forward_list单向链表的使用
C++ STL总结（五）forward_list
qq_36383272的博客
09-14 2499
1.forward_list内存结构 forward_list是单向链表，内存结构与list类似，只不过是单向的 2.forward_list容量操作 函数 功能 bool empty() 检查容器是否为空 size_t max_size() 返回容器由于系统或库的实现所限制可容纳的元素最大数量 void resize(size_t new_size, const T& x) 重设容器的size大小，如果size变大，则以默认值填充变长的位置，如果size变小，则删除变短那
STL forward_list 模拟实现
叫我小秦就好了的博客
01-11 815
forward_list 是 C++ 11 新增的容器，它的实现为单链表。 forward_list 是支持从容器中的任何位置快速插入和移除元素的容器，不支持快速随机访问。forward_list 和 list 的主要区别在于，前者的迭代器属于单向的 Forward Iterator，后者的迭代器属于双向的 Bidirectional Iterator。
C++利用std::forward_list查找插入数据方法示例
08-29
主要给大家介绍了关于C++利用std::forward_list查找插入数据的相关资料，文中先对std::forward_list进行了详细的介绍，而后通过示例代码给大家介绍了查找的方法，需要的朋友可以参考借鉴，下面话不多说了，来一起看...
forword_list类的实现
04-24
这个数据结构主要用于实现无序、线性序列，与`std::list`不同，`forward_list`不支持双向遍历，只能向前遍历，这使得它的内存分配和遍历效率更高。在悉尼大学的课程作业中，使用VS2019开发环境来实现`forward_list`...
list_list_STL_C++_
09-29
`list`容器通常用`std::list`来表示，其元素类型由模板参数指定，例如`std::list<int>`表示存储整数的链表。 **2. list容器的成员函数** `list`提供了丰富的成员函数来操作链表： - **构造与初始化**：`list()`无...
Leetcode_Basic-Notes:Leetcode模板技巧积累
03-27
C++中的`std::list`和`std::forward_list`是链表实现。 - 栈与队列：C++标准库提供了`std::stack`和`std::queue`，它们分别实现了后进先出（LIFO）和先进先出（FIFO）的概念。 - 树结构：二叉树、AVL树、红黑树等...
STL-.rar_C 知识点
09-24
STL的容器包括数组（`std::array`）、向量（`std::vector`）、列表（`std::list`）、链表（`std::forward_list`和`std::list`）、集合（`std::set`和`std::multiset`）、映射（`std::map`和`std::multimap`）等。...
C++STL：顺序容器之forward_list
crossoverpptx的博客
07-12 1446
forward_list 是 C++ 11 新添加的一类容器，其底层实现和 list 容器一样，采用的也是链表结构，只不过 forward_list 使用的是单链表，而 list 使用的是双向链表。more如下图所示：上图中，H 表示链表的表头。a) 表示单链表，b) 表示双向链表。不难看出，使用链表存储数据最大的特点在于，其并不会将数据进行集中存储（向数组那样），换句话说，链表中数据的存储位置是分散的、随机的，整个链表中数据的线性关系通过指针来维持。
基于C++11的Forward-List容器分析
Reol99999的博客
03-01 298
基于C++11的forward list容器分析
深入学习c++(STL之容器，stdforward_list）
u010665493的博客
02-19 244
#include <#include <forward_list>> // vector 是 c++ 98中引入的动态数组 namespace std { template<typename T,typename Allocator = allocator<T>> class forward_list; } // forward_list...
突破编程_C++_C++11新特性（forward_list）
最新发布
突破编程
03-19 1473
C++11 新特性：forward_list
STL教程(四): 序列容器--forward_list
王木木
01-15 729
一、forward_list简介 template< class T, class Allocator = std::allocator<T> > class forward_list; 参数介绍： T：包含的元素的类型，即array::value_type。 Allocator：一个分配器，用于获取/释放内存以及构造/销毁该内存中的元素 forward_list是一个序列容器，它的底层实现为单向链表，允许在序列中的任何位置进行恒...
c++stl和std_C ++ STL转发列表容器– std :: forward_list
culing2941的博客
09-15 322
c++stl和stdIn this tutorial you will learn about C++ STL forward list i.e., std::forward_list and operations, methods applicable on it. 在本教程中，您将了解C ++ STL转发列表，即std :: forward_list和操作以及适用于它的方法。 Forwar...
C++ 11 新特性： std::array和std::forward_list
freshman94的博客
04-18 1214
std::array std::array是C++11新增加的类型。与内置数组相比，array是一种更安全、更容易使用的数据类型，定义于头文件<array>中。与内置数组类似，array对象的大小是固定的，因此，array不支持添加和删除元素以及改变窗口大小的操作。而且它不会退化成指针。 从cppreference.com得知其定义为： template< class ...
C++11中std::forward的使用
热门推荐
网络资源是无限的
09-19 2万+
C++11中std::forward的使用
std::vector与std::list数据结构区别
07-28
`std::vector` 和 `std::list` 是两种不同的数据结构，各有自己的特点和适用场景。以下是它们之间的一些主要区别： 1. 存储方式：`std::vector` 是一个动态数组，它使用连续的内存块来存储元素，可以通过索引快速访问元素。而 `std::list` 是一个双向链表，它的元素通过指针链接在一起，不能通过索引直接访问元素，需要遍历链表来访问。 2. 插入和删除操作：由于 `std::vector` 使用连续的内存存储元素，插入和删除元素可能涉及到内存的重新分配和元素的移动，因此在特定位置进行插入和删除操作的成本较高。而 `std::list` 作为链表，在任意位置进行插入和删除操作的成本都是常数时间复杂度，不涉及元素的移动。 3. 访问和查找操作：由于 `std::vector` 使用连续的内存存储元素，可以通过索引直接访问元素，也可以通过指针进行迭代，因此在访问和查找操作上比较高效。而 `std::list` 作为链表，访问和查找操作需要遍历整个链表，时间复杂度较高。 4. 内存分配：由于 `std::vector` 使用连续的内存存储元素，它在内存分配上是连续的，有利于 CPU 缓存的利用。而 `std::list` 的内存分配是离散的，可能导致额外的内存碎片。 根据上述区别，可以根据实际需求选择合适的数据结构。如果需要频繁进行随机访问、插入和删除操作不频繁，并且对内存占用有限制，可以使用 `std::vector`。如果需要频繁进行插入和删除操作、访问和查找操作相对较少，并且不关心内存占用，可以使用 `std::list`。当然，在特定情况下，也可以根据具体需求选择其他数据结构，如 `std::deque` 或 `std::forward_list`。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值