c++11 标准模板（STL）（std::forward_list）（十二）

最新推荐文章于 2024-11-02 20:20:37 发布
最新推荐文章于 2024-11-02 20:20:37 发布
阅读量616 收藏
点赞数 1
分类专栏： # std::forward_list 文章标签： c++ 容器 单链表 forward_list splice_after
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788199/article/details/128771342
版权

定义于头文件 <forward_list>

template<

    class T,
    class Allocator = std::allocator<T>

> class forward_list;		(1)(C++11 起)
namespace pmr {

    template <class T>
    using forward_list = std::forward_list<T, std::pmr::polymorphic_allocator<T>>;

}		(2)(C++17 起)

std::forward_list 是支持从容器中的任何位置快速插入和移除元素的容器。不支持快速随机访问。它实现为单链表，且实质上与其在 C 中实现相比无任何开销。与 std::list 相比，此容器提在不需要双向迭代时提供更有效地利用空间的存储。

在链表内或跨数个链表添加、移除和移动元素，不会非法化当前指代链表中其他元素的迭代器。然而，在从链表移除元素（通过 erase_after ）时，指代对应元素的迭代器或引用会被非法化。

std::forward_list 满足容器 (Container) （除了 operator== 的复杂度始终为线性和 size 函数）、具分配器容器 (AllocatorAwareContainer) 和序列容器 (SequenceContainer) 的要求。

操作

从另一 forward_list 移动元素

std::forward_list<T,Allocator>::splice_after

void splice_after( const_iterator pos, forward_list& other );

(1)(C++11 起)

void splice_after( const_iterator pos, forward_list&& other );

(1)(C++11 起)

void splice_after( const_iterator pos, forward_list& other,
                   const_iterator it );

(2)(C++11 起)

void splice_after( const_iterator pos, forward_list&& other,
                   const_iterator it );

(2)(C++11 起)

void splice_after( const_iterator pos, forward_list& other,
                   const_iterator first, const_iterator last );

(3)(C++11 起)

void splice_after( const_iterator pos, forward_list&& other,
                   const_iterator first, const_iterator last );

(3)(C++11 起)

 

从另一 forward_list 移动元素到 *this 。

不复制元素。 pos 必须是指向 *this 中的可解引用迭代器或 before_begin() 迭代器（特别是 end() 不是 pos 的合法参数值）。若 get_allocator() != other.get_allocator() 则行为未定义。没有迭代器或引用被非法化，指向被移动的元素的迭代器现在指代到 *this 中，而非 other 中。

1) 从 other 移动所有元素到 *this 。元素被插入到 pos 所指向的元素后。操作后 other 变为空。若 other 与 *this 指代同一对象则行为未定义。

2) 从 other 移动后随 it 的迭代器所指向的元素到 *this 。元素被插入到 pos 所指向的元素后，若 pos == it 或若 pos == ++it 则无效果。

3) 从 other 移动范围 (first, last) 中的元素到 *this 。元素被插入到 pos 所指向的元素后。不移动 first 所指向的元素。若 pos 是范围 (first,last) 中的元素则行为未定义。

参数

pos-指向将插入内容到其后的元素的迭代器
other-移动内容来源的另一容器
it-指向从 other 移动到 *this 的元素的迭代器的前趋迭代器
first, last-从 other 移动到 *this 的元素范围

返回值

（无）

异常

不抛出。

复杂度

1) 与 other 的大小成线性

2) 常数

3) 与 std::distance(first, last) 成线性

调用示例

#include <iostream>
#include <forward_list>
#include <string>
#include <iterator>
#include <algorithm>
#include <time.h>

using namespace std;

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }

    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

int main()
{
    std::cout << std::boolalpha;

    std::mt19937 g{std::random_device{}()};
    srand((unsigned)time(NULL));

    auto generate = []()
    {
        int n = std::rand() % 10 + 100;
        Cell cell{n, n};
        return cell;
    };

    std::forward_list<Cell> forward_list1(3);
    std::generate(forward_list1.begin(), forward_list1.end(), generate);
    std::cout << "forward_list1:    ";
    std::copy(forward_list1.begin(), forward_list1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::forward_list<Cell> forward_list2(3);
    std::generate(forward_list2.begin(), forward_list2.end(), generate);
    std::cout << "forward_list2:    ";
    std::copy(forward_list2.begin(), forward_list2.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    //1) 从 other 移动所有元素到 *this 。
    forward_list1.splice_after(forward_list1.begin(), forward_list2);
    std::cout << "splice_after:     ";
    std::copy(forward_list1.begin(), forward_list1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;


    std::forward_list<Cell> forward_list3(3);
    std::generate(forward_list3.begin(), forward_list3.end(), generate);
    std::cout << "forward_list3:    ";
    std::copy(forward_list3.begin(), forward_list3.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::forward_list<Cell> forward_list4(3);
    std::generate(forward_list4.begin(), forward_list4.end(), generate);
    std::cout << "forward_list4:    ";
    std::copy(forward_list4.begin(), forward_list4.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    //1) 从 other 移动所有元素到 *this 。移动语义。
    forward_list3.splice_after(forward_list3.begin(), std::move(forward_list4));
    std::cout << "splice_after:     ";
    std::copy(forward_list3.begin(), forward_list3.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;


    std::forward_list<Cell> forward_list5(3);
    std::generate(forward_list5.begin(), forward_list5.end(), generate);
    std::cout << "forward_list5:    ";
    std::copy(forward_list5.begin(), forward_list5.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::forward_list<Cell> forward_list6(3);
    std::generate(forward_list6.begin(), forward_list6.end(), generate);
    std::cout << "forward_list6:    ";
    std::copy(forward_list6.begin(), forward_list6.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    //2) 从 other 移动后随 it 的迭代器所指向的元素到 *this 。
    forward_list5.splice_after(forward_list5.begin(), forward_list6, forward_list6.before_begin());
    std::cout << "splice_after:     ";
    std::copy(forward_list5.begin(), forward_list5.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;


    std::forward_list<Cell> forward_list7(3);
    std::generate(forward_list7.begin(), forward_list7.end(), generate);
    std::cout << "forward_list7:    ";
    std::copy(forward_list7.begin(), forward_list7.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::forward_list<Cell> forward_list8(3);
    std::generate(forward_list8.begin(), forward_list8.end(), generate);
    std::cout << "forward_list8:    ";
    std::copy(forward_list8.begin(), forward_list8.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    //2) 从 other 移动后随 it 的迭代器所指向的元素到 *this 。 移动语义。
    forward_list7.splice_after(forward_list7.begin(), std::move(forward_list8), forward_list8.before_begin());
    std::cout << "splice_after:     ";
    std::copy(forward_list7.begin(), forward_list7.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;


    std::forward_list<Cell> forward_list9(3);
    std::generate(forward_list9.begin(), forward_list9.end(), generate);
    std::cout << "forward_list9:    ";
    std::copy(forward_list9.begin(), forward_list9.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::forward_list<Cell> forward_list10(3);
    std::generate(forward_list10.begin(), forward_list10.end(), generate);
    std::cout << "forward_list10:   ";
    std::copy(forward_list10.begin(), forward_list10.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    //3) 从 other 移动范围 (first, last) 中的元素到 *this 。
    forward_list9.splice_after(forward_list9.begin(), forward_list10, forward_list10.begin(), forward_list10.end());
    std::cout << "splice_after:     ";
    std::copy(forward_list9.begin(), forward_list9.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;


    std::forward_list<Cell> forward_list11(3);
    std::generate(forward_list11.begin(), forward_list11.end(), generate);
    std::cout << "forward_list11:   ";
    std::copy(forward_list11.begin(), forward_list11.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::forward_list<Cell> forward_list12(3);
    std::generate(forward_list12.begin(), forward_list12.end(), generate);
    std::cout << "forward_list12:   ";
    std::copy(forward_list12.begin(), forward_list12.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    //2) 从 other 移动后随 it 的迭代器所指向的元素到 *this 。 移动语义。
    forward_list11.splice_after(forward_list11.begin(), std::move(forward_list12), forward_list12.begin(), forward_list12.end());
    std::cout << "splice_after:     ";
    std::copy(forward_list11.begin(), forward_list11.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    return 0;
}

输出

 

繁星璀璨G
关注
专栏目录
一篇搞懂C++ STL 单向链表std::forward_list
m0_62599305的博客
08-30 1045
C++标准模板库（STL）提供了多种容器类来处理不同的数据结构，其中是用于实现单向链表（Singly Linked List）的容器。与其他容器如std::list相比，更为轻量，专为需要快速插入和删除操作、以及内存效率的应用场景而设计。本篇文章将详细介绍的特性、与std::list的区别、所有构造函数和操作函数，并通过示例代码帮助你全面理解这一容器的使用方法。是C++11引入的单向链表容器。它的设计非常简单，仅包含指向下一个节点的指针，因此与双向链表（std::list）相比，它占用的内存更少。
c++11 标准模板（STL）（std::forward_list）（五）
qq_40788199的博客
01-12 538
返回指向首元素前一元素的迭代器。此元素表现为占位符，试图访问它会导致未定义行为。 返回指向容器首元素的迭代器。若容器为空，则返回的迭代器将等于 end() 。 返回指向容器末元素后一元素的迭代器。此元素表现为占位符；试图访问它导致未定义行为。
C++必修：STL之forward_list与list的使用
Bettysweetyaaa的博客
08-09 1168
这篇文章聚焦 C++ 中的 `forward_list` 和 `list` 容器。详解其特点，如内存高效利用、擅长特定操作等。还涵盖初始化、容量操作、访问与修改等多方面。助您深入了解，提升编程技能，不容错过！
C++ 学习笔记9-std::forward_list 五
谢白羽
05-27 261
文章目录一、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.没有任何时间和空间上的额外开销，
突破编程_C++_C++11新特性（forward_list）
突破编程
03-19 1768
C++11 新特性：forward_list
c++11 标准模板（STL）（std::forward_list）（一）
qq_40788199的博客
01-08 556
std::forward_list 是支持从容器中的任何位置快速插入和移除元素的容器。不支持快速随机访问。它实现为单链表，且实质上与其在 C 中实现相比无任何开销。与 std::list 相比，此容器提在不需要双向迭代时提供更有效地利用空间的存储。
c++标准模板（STL）（std::list）（七）
qq_40788199的博客
10-05 1170
std::list 是支持常数时间从容器任何位置插入和移除元素的容器。不支持快速随机访问。它通常实现为双向链表。与 std::forward_list 相比，此容器提供双向迭代但在空间上效率稍低。 在 list 内或在数个 list 间添加、移除和移动元素不会非法化迭代器或引用。迭代器仅在对应元素被删除时非法化。
C++STL：顺序容器之forward_list
crossoverpptx的博客
07-12 1615
forward_list 是 C++ 11 新添加的一类容器，其底层实现和 list 容器一样，采用的也是链表结构，只不过 forward_list 使用的是单链表，而 list 使用的是双向链表。more如下图所示：上图中，H 表示链表的表头。a) 表示单链表，b) 表示双向链表。不难看出，使用链表存储数据最大的特点在于，其并不会将数据进行集中存储（向数组那样），换句话说，链表中数据的存储位置是分散的、随机的，整个链表中数据的线性关系通过指针来维持。
C++学习第二十课：STL中的`list`和`forward_list`深度解析
2401_84585615的博客
05-03 461
std::list和都是顺序容器，但它们在底层实现和操作上有所不同。通过本课的学习，你全面了解了STL中的std::list和容器，包括其初始化、元素访问、大小管理、添加和移除元素、迭代器使用、内存管理、性能考量、异常安全性、特化和偏特化、实际应用、线程安全性以及未来发展。std::list和是C++中处理链表的强大工具，它们在某些场景下提供了比更高的性能和灵活性。掌握这两种容器的使用对于编写高效、安全、可维护的C++程序至关重要。
C++11标准库(STL)使用总结——forward_list
程序猿之家
09-10 4411
forward_list（单向链表）是序列容器，允许在序列中的任何地方进行恒定的时间插入和擦除操作。 forward_list（单向链表）被实现为单链表; 单链表可以将它们包含的每个元素存储在不同和不相关的存储位置中。通过关联到序列中下一个元素的链接的每个元素来保留排序。forward_list容器和列表 之间的主要设计区别容器是第一个内部只保留一个到下一个元素的链接，而后者每个元素保留两个链接：...
C++(STL):14--- forward_list比list更高效的容器
网易搬砖选手
12-14 299
forward_list 是C++11 新添加的一类容器，其底层实现和 list 容器一样，采用的也是链表结构，只不过 forward_list 使用的是单链表，而 list 使用的...
【STL】顺序容器之list、forward_list用法总结
WYuan的博客
12-15 1550
        一、基本原理         list是双向链表，forward_list是单向链表，在链表的任何位置添加或删除元素都很快，但是作为代价，这两个容器都不支持随机访问，为了访问容器中的某一个元素，我们只能遍历整个容器。        forward_list是C++新标准增加的类型，其设计目标是达到与最好的手写单向链表数据结构相当的性能，因此forward_list没有siz
源码剖析STL内存分配器 std::allocator，让你能硬刚面试官
loOK后端
03-03 1973
本期主要讲解C++ STL中的内存分配器std::allocator及其特性萃取器__gnu_cxx::__alloc_traits。 为防止混淆，规定如下： allocator：泛指内存分配器，仅仅是一个术语。 std::allocator：是STL实现的内存分配器类std::allocator。 更多硬核知识，欢迎关注： __gnu_cxx::new_allocator C++的默认的内存分配器std::allocator，继承至__gnu_cxx::new_allocator。而 __gnu
C++移动语义交互：std::initializer_list在高级编程中的6个关键点
[C++移动语义交互：std::initializer_list在高级编程中的6个关键点](https://i0.wp.com/feabhasblog.wpengine.com/wp-content/uploads/2019/04/Initializer_list.jpg?ssl=1) # 1. 移动语义与C++11新特性 ## 1.1 ...
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 202
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2242
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 55
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1160
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C++ -- 模板进阶
最新发布
zy1215058242的博客
11-02 542
一个程序/项目由若干源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。模板会导致会导致代码代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。
C++教程：理解单向链表与forward_list操作
学习`std::forward_list`不仅可以帮助开发者理解C++标准模板库（STL）中的容器，还能提升他们在实际项目中选择合适数据结构的能力。通过熟练掌握`std::forward_list`的用法，开发者可以编写出更高效、更简洁的C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值