STL容器之＜forward_list＞

测试环境

系统：ubuntu 22.04.2 LTS 64位
gcc版本：11.3.0
编辑器：vsCode 1.76.2

forward_list介绍

1. 序列式容器
2. 不支持随机访问。
3. 不支持反向迭代器。
4. 元素存储在不同且不相关的存储单元中。
5. 频繁插入、提取、移动和删除元素时效率较高。
6. 单项链表（list是双向链表）。

头文件

#include 

模块类定义

_Tp：表示存储的元素数据类型
_Alloc：表示所存储分配器的类型，负责元素内存的分配和释放。可选参数，一般不使用。

template<typename _Tp, typename _Alloc = allocator<_Tp>>
    class forward_list{} 

对象构造

/*默认构造函数,没有元素*/
std::forward_list<int> fwLstInt1; 
/*构造指定长度的对象，含有10个元素默认为0*/
std::forward_list<int> fwLstInt2(10);
/*构造指定长度的指定值的对象，还有10个6*/
std::forward_list<int> fwLstInt3(10,6);
/*复制拷贝构造函数，含有10个6*/
std::forward_list<int> fwLstInt4(fwLstInt3);
/*使用fwLstInt3的前7个元素构造对象*/
std::forward_list<int> fwLstInt5(fwLstInt3.begin(),fwLstInt3.end());
/*移动构造函数，构造后fwLstInt5不可在使用*/
std::forward_list<int> fwLstInt6(std::move(fwLstInt5));
/*初始化列表构造链表*/
std::forward_list<int> fwLstInt7({1,2,3,4,5,6,7,8,9,0});

初始化

函数	返回值	功能
assign()	无	情况链表中的元素并用指定数据进行赋值

/*初始化列表初始化*/
fwLstInt1 = {1,2,3,4,5};
/*使用assign函数初始化,清空容器，并使用迭代器进行赋值*/
fwLstInt1.assign(fwLstInt6.cbegin(), fwLstInt6.cend());
/*赋值5个8*/
fwLstInt1.assign(5,8);
/*assign中使用初始化列表赋值*/
fwLstInt1.assign({8,7,6,5,4,3,2,1});

元素访问

函数名	返回值	功能
front()	首元素的引用	获取首元素，链表为空时返回值不确定

/* 访问对象第一个元素和最后一个元素 */
std::cout << lstInt1.front() << std::endl;

元素插入和删除

函数	返回值	功能
clear()	无	清空所有元素
erase_after()	迭代器	清除指定位置之后的一个元素或删除通过迭代器指定范围内的元素
emplace_after()	迭代器	在指定位置移动构造一个新元素
emplace_front()	无	在链表头直接移动构造一个新元素
insert_after()	迭代器或无	1）在指定位置插入1个元素。2）在指定位置插入指定数量的相同元素。3）通过指定迭代器范围在指定位置插入数据.4）在指定位置使用初始化列表插入元素
pop_front()	无	删除链表头元素
push_front()	无	链表头插入元素
remove()	无	删除与指定值相同的所有元素
remove_if()	无	按用户自定义条件删除元素

std::forward_list<int> fwLstTest1({1,2,4,5});
/*在链表头插入元素*/
fwLstTest1.push_front(88);
/*使用移动语句在链标题插入元素*/
int iValue2 = 34;
fwLstTest1.push_front(std::move(iValue2));
/* 在容器头插入元素 */
fwLstInt1.emplace_front(10);
/* 清除指定位置的一个元素 */
fwLstTest1.erase_after(++fwLstTest1.begin());
/* 清除从指定位置范围内的元素 */
fwLstTest1.erase_after(fwLstTest1.begin(), ++fwLstTest1.begin());
/*在指定位置插入元素*/
fwLstTest1.insert_after(++fwLstTest1.begin(),66);
/*在指定位置插入指定数量的相同数据*/
fwLstTest1.insert_after(fwLstTest1.begin(),3,8);
/*在指定位置通过插入指定迭代器范围之间的数据*/
fwLstTest1.insert_after(fwLstTest1.begin(),  fwLstInt3.begin(), ++fwLstInt3.begin());
/*在指定位置插入初始化列表中的数据*/
fwLstTest1.insert_after(fwLstTest1.begin(), {1,2,3});
/*使用移动语句插入元素*/
int iValue = 33;
fwLstTest1.insert_after(fwLstTest1.begin(), std::move(iValue));
/*删除链表头部元素*/
fwLstTest1.pop_front();
/*删除指定位置之后的元素（删除第2个元素）*/
fwLstTest1.erase_after(fwLstTest1.begin());
/*删除指定范围内的元素（删除第2个元素）*/
auto itr2 = ++fwLstTest1.begin();
fwLstTest1.erase_after(fwLstTest1.begin(), ++itr2);
/*删除链表中与指定值相同的所有元素*/
fwLstTest1.remove(8);
/*删除大于10的所有元素*/
class delThanTen
{
public:
    bool operator()(int &element)
    {
        return element > 10;
    }
};
fwLstTest1.remove_if(delThanTen());
/*清空所有元素*/
fwLstTest1.clear();

容器大小

函数	返回值	功能
empty()	bool	判断链表是否为空，为空返回true，否则返回false
max_size()	std::size_t	返回容器的最大容量
reverse()	无	反转链表中的元素排列顺序
resize()	无	重新指定容器可以容纳的元素数量，新大小大于原本大小时超出部分可使用指定元素填充(在链表首填充)，如果新大小小于指定大小时会删除容器原本链表首的数据。

fwLstTest1 = {1,2,3,4,5,6,7};
/*判断容器是否为空*/
std::cout << std::boolalpha << fwLstTest1.empty() << std::endl;
/*重新设置容器的大小*/
fwLstTest1.resize(30);
/*获取容器最大可分配的容量大小*/
std::cout << fwLstTest1.max_size() << std::endl;
/*反转链表元素*/
fwLstTest1.reverse();

迭代器

类型	功能
iterator	正向访问迭代器。从前向后访问元素，可以读取也可以修改
const_iterator	常量正向访问迭代器。从前向后访问元素，只能读取不能修改

函数	返回值	功能
before_begin()	正向访问迭代器	返回指向forward_list对象首元素的前一个位置
cbefore_begin()	常量正向访问迭代器	返回指向forward_list对象首元素的前一个位置
begin()	正向访问迭代器	返回指向forward_list对象首元素所在位置的迭代器
end()	正向访问迭代器	返回指向forward_list对象末尾元素的下一个位置的迭代器
cbegin()	常量正向访问迭代器	返回指向forward_list对象首元素所在位置的常量迭代器
cend()	常量正向访问迭代器	返回指向forward_list对象末尾元素的下一个位置的迭代器

注：使用在指定位置之后插入元素接口时，如在链表头插入元素时使用before_begin()，使用begin()，会在第二个位置插入元素。因为before_begin()指向的是链表头。单练表只支持自增（++）操作。

std::forward_list<int> fwLstTest4 = {10,11,12,13,14,15,16,17,18,19};
/*正向访问迭代器，每个元素+10，并打印输出（20 21 22 23 24 25 26 27 28 29）*/
std::forward_list<int>::iterator itr;
for (itr = fwLstTest4.begin(); itr != fwLstTest4.end(); itr++)
{
    /* 修改元素值每个元素+10 */
    *itr += 10; 
    /* 访问元素 */
    std::cout << *itr << " ";
}
std::cout<<std::endl;
/*常量正向访问迭代器，并打印输出（20 21 22 23 24 25 26 27 28 29）*/
std::forward_list<int>::const_iterator cItr;
for (cItr = fwLstTest4.begin(); cItr != fwLstTest4.end(); cItr++)
{
    /* 不允许修改值，编译报错 */
    //*cItr += 10; 
    /* 访问元素 */
    std::cout << *cItr << " ";
}
std::cout<<std::endl;

其他函数

函数名	返回值	功能
merge()	无	合并两个链表，并按指定规则排序
sort()	无	按升序或用户指定的顺序排列元素
swap()	无	交换两个容器的元素
splice_after()	无	将一个链表中的元素添加到另一个链表中，并将原链表中的元素删除
unique()	无	删除相邻的重复元素，或者按指定规则删除元素

/*交互两个容器元素的值,无返回值*/
std::forward_list<int> fwLstSwap1 = {1,2,3,4,5};
std::forward_list<int> fwLstSwap2 = {5,4,3,2,1};
/*方式1， fwLstSwap1={5,4,3,2,1}, fwLstSwap2={1,2,3,4,5}*/
fwLstSwap1.swap(fwLstSwap2);
/*方式2，fwLstSwap1={1,2,3,4,5}, fwLstSwap2={5,4,3,2,1}*/
std::swap(fwLstSwap1,fwLstSwap2);
/*如果初始链表为无序的则合并后也是无序的*/
/*合并两个序列默认按升序排列，两个链表必须是按升序排列的*/
fwLstSwap1 = {1,2,3,4,5};
fwLstSwap2 = {1,2,3,4,5};
fwLstSwap1.merge(fwLstSwap2);
/*合并两个列表并按降序排列，两个链表必须是按降序排列的*/
fwLstSwap1 = {5,4,3,2,1};
fwLstSwap2 = {5,4,3,2,1};
fwLstSwap1.merge(fwLstSwap2,std::greater<int>());
/*将链表排序，无参数时默认升序排列*/
fwLstSwap1.sort(std::greater<int>());

std::forward_list<int> fwLstSplice1 = {5,4,3,2,1};
std::forward_list<int> fwLstSplice2 = {5,4,3,2,1};
/* 将fwLstSplice2的第二个元素加入到fwLstSplice1的第二个位置，并在fwLstSplice2中删除 */
fwLstSplice1.splice_after(fwLstSplice1.begin(), fwLstSplice2, ++fwLstSplice2.before_begin());
/* 将fwLstSplice2的元素加入到fwLstSplice1的首部，并在fwLstSplice2中删除 */
fwLstSplice1.splice_after(fwLstSplice1.before_begin(), fwLstSplice2, fwLstSplice2.begin(), fwLstSplice2.end());
/*将lstSplice1中的元素加入lstSplice2,并将lstSplice1中的元素删除*/
fwLstSplice2.splice_after(fwLstSplice2.before_begin(), fwLstSplice1);
    
fwLstTest1 = {1,1,2,2,3,3,5,3,5};
/*删除相连的相同元素*/
fwLstTest1.unique();
/*删除相连不相同的元素*/
std::not_equal_to<int> compare;
fwLstTest1.unique(compare);