std::forward_list

最新推荐文章于 2025-10-15 11:02:57 发布
原创 最新推荐文章于 2025-10-15 11:02:57 发布 · 735 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#list #链表 #数据结构

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

起始

一篇搞懂C++ STL 单向链表std::forward_list
m0_62599305的博客
08-30 1366
C++标准模板库（STL）提供了多种容器类来处理不同的数据结构，其中是用于实现单向链表（Singly Linked List）的容器。与其他容器如std::list相比，更为轻量，专为需要快速插入和删除操作、以及内存效率的应用场景而设计。本篇文章将详细介绍的特性、与std::list的区别、所有构造函数和操作函数，并通过示例代码帮助你全面理解这一容器的使用方法。是C++11引入的单向链表容器。它的设计非常简单，仅包含指向下一个节点的指针，因此与双向链表（std::list）相比，它占用的内存更少。
容器库(4)-std::forward_list
Lucy_stone的博客
02-06 2469
std::forward_list是可以从任何位置快速插入和移除元素的容器，不支持快速随机访问，只支持正向迭代。
突破编程_C++_C++11新特性（forward_list）
突破编程
03-19 2161
C++11 新特性：forward_list
C++ 容器详解：std::list 与 std::forward_list 深入解析
最新发布
2401_84382970的博客
10-15 884
std::list和都是 C++ STL 中的链表容器，用于存储动态大小的元素集合。特性std::list链表类型双向链表单向链表插入/删除效率任意位置 O(1)任意位置 O(1)随机访问不支持不支持内存占用较高（每个节点包含前后指针）较低（仅有后继指针）适用场景需要频繁中间插入/删除内存敏感且仅需单向遍历容器优点缺点适用场景std::list插入/删除高效，支持双向遍历内存占用高，不支持随机访问频繁中间插入/删除占用低，插入/删除高效仅单向遍历。
C++利用std::forward_list查找插入数据方法示例
08-29
主要给大家介绍了关于C++利用std::forward_list查找插入数据的相关资料，文中先对std::forward_list进行了详细的介绍，而后通过示例代码给大家介绍了查找的方法，需要的朋友可以参考借鉴，下面话不多说了，来一起看看吧。
C++11中std::forward_list单向链表的使用
网络资源是无限的
06-04 5854
C++11中std::forward_list单向链表的使用
深入理解 `std::forward_list`
深耕嵌入式领用多年， 致力于分享嵌入式领域技术!
08-07 532
深入理解 `std::forward_list`
C++11 新特性：std::forward_list 前向列表
kelvin_yin的专栏
04-10 522
std::forward_list 是 C++11 中引入的一个高效的单向链表容器，它提供了灵活的元素管理方法，适用于需要频繁进行插入和删除操作的场景。由于其内部实现只维护单向链接，在空间使用上比std::list更加高效。通过合理利用提供的方法，可以在保证性能的同时，编写出清晰、简洁的代码。
上下定高 中间自适应_上下固定高，中间自适应
weixin_39822443的博客
12-20 261
自适应body{padding: 0;margin: 0; }/*在无内容的情况下也能显示出自适应元素需要两个条件：(所有元素的宽一致)1、父元素高度；1.1、已知了自适应元素(box2)上下元素的高，还需知道父元素的高，这样自适应元素才能算出自己的高；1.2、由于高度已经固定，如果超出高度，可使用overflow:scroll解决；2、使用绝对定位；2.1、使用了绝对定位，确定了元素相对于父元素...
c++11 标准模板（STL）（std::forward_list）（五）
qq_40788199的博客
01-12 590
返回指向首元素前一元素的迭代器。此元素表现为占位符，试图访问它会导致未定义行为。 返回指向容器首元素的迭代器。若容器为空，则返回的迭代器将等于 end() 。 返回指向容器末元素后一元素的迭代器。此元素表现为占位符；试图访问它导致未定义行为。
【C++】std::forward_list
2302_79865304的博客
09-08 672
是 C++ 标准库中的一个单向链表容器。与std::list相比，只允许单向遍历，即只能从前往后访问元素。它的实现比std::list更轻量，因此在内存和性能方面通常更优，但缺少双向访问的能力。
C++ 学习笔记9-std::forward_list 五
谢白羽
05-27 330
文章目录一、forwad_list1.forwad_list的介绍2.forward_list的特点3.forward_list不提供的函数4.元素访问，不能随机访问5.迭代器相关有影响6.删除和插入7.算法相关 一、forwad_list 1.forwad_list的介绍 2.forward_list的特点 1.不支持随机访问元素，访问头部元素速度快 2.forward_list和自己手写的c-style singly linked list相比，没必要自己造轮子 3.没有任何时间和空间上的额外开销，
STL学习----入门（1）[forward_list]
深藏功与名
08-24 1312
 学了一半的头文件到这儿了。 #include: C++11 // template class T, class Alloc = allocatorT> > class forward_list; 正向列表（Forward list）是一个允许在序列中任何一处位置以常量耗时插入或删除元素的顺序容器（Sequence container）。 A forward_lis
深入学习c++(STL之容器，stdforward_list）
u010665493的博客
02-19 309
#include <#include <forward_list>> // vector 是 c++ 98中引入的动态数组 namespace std { template<typename T,typename Allocator = allocator<T>> class forward_list; } // forward_list...
C++学习笔记（三十三）——forward_list
weixin_45857378的博客
04-01 767
std::forward_list 是 C++的STL中的单向链表（Singly Linked List），它相比 std::list（双向链表）更轻量，适用于仅需要单向遍历的场景。
QLinkedList和std::forward_list
hai200501019的专栏
09-17 1742
forward_list forward_list是C++11版本才有的。forward_list被实现为单链表，而list是一个双向链表，所以forward_list要比list高效一些。forward_list设计的时候就是追求效率的，跟我们自己写的C格式的单链表一样的高效。 考虑到效率问题，forward_list没有size成员函数。由于它本质是一个链表，有一个size成员会耗费常量的
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值