本节我们将介绍 STL 中的 forward_list 容器使用。
forward_list 容器以单链表的形式存储元素。其模板定义在头文件 forward_list 中。forward_list 和 list 最主要的区别是: 它不能反向遍历元素，而只能从头到尾遍历。
forward_list 的单向链接性也意味着它会有一些其他的特性：
1.无法使用反向迭代器。只能从它得到 const 或 non-const 前向迭代器，这些迭代器都不能解引用，只能自增；
2.没有可以返回最后一个元素引用的成员函数 back() ，只有成员函数 front() 。
3.因为只能通过自增前面元素的迭代器来到达序列的终点，所以push_back()，pop_back()，emplace_back()也无法使用。
尽管 forward_list 在使用上有很多限制，但是它的操作比 list 容器还要快，而且占用的内存更少。从这点来看，它还是可以令人满意的。
forward_list 容器的构造函数的使用方式和 list 容器相同，这里可以参考往期有关 list 的构造方法，大同小异。
forward_list 的迭代器都是前向迭代器。它没有成员函数 size()，因此不能用一个前向迭代器减去另一个前向迭代器，但是可以使用在头文件 iterator 中的 distance() 函数来得到元素的个数。
例如：
forward_list<string> data {"one","null","three","four","null","six","seven"};
int count = distance(begin(data),end(data));
count 的值为 3；
distance() 的第一个参数是一个开始迭代器，第二个参数是一个结束迭代器，它们指定了元素范围。
当需要将前向迭代器移动多个位置时，我们就可以使用 advance() 了。
forward_list<string> data {"one","null","three","four","null","six","seven"};
forward_list<string>::iterator iter = begin(data);
int step = 4;
advance(iter,4);
//*iter = "null"
和之前类似，advance() 函数会将前向迭代器自增需要的次数。这使我们不必去循环自增迭代器。需要记住的是这个函数自增的是作为第一个参数的迭代器，但是并不会返回它——advance() 的返回类型为 void。
这里有个细节，forward_list 只能从头到尾遍历，如果是 end(data) 它是不能移动的，我们简单汇总下容器的构造和迭代器吧。
#include <bits/stdc++.h>
using namespace std;
int main(){
forward_list<string> data_ {"one","null","three","four","null","six","seven"};
//begin_iter_ 可以单向移动
auto begin_iter_ = begin(data_);
//end_iter_ 不可以移动
forward_list<string>::iterator end_iter_ = end(data_);
int len_data_ = distance(begin_iter_,end_iter_);
cout<<"data_ : "<<len_data_<<endl;
for(auto d : data_){
cout<<d<<" ";
}
cout<<endl;
cout<<"move begin_iter_ :"<<endl;
//使用 advance() 移动 begin_iter_
int step = 2;
advance(begin_iter_,step);
len_data_ = distance(begin_iter_,end_iter_);
cout<<"end_iter_ - begin_iter_ = "<<len_data_<<endl;
// 将 begin_iter_ 和 end_iter_ 之间的内容赋值给 data
forward_list<string> data(begin_iter_,end_iter_);
auto begin_iter = begin(data);
forward_list<string>::iterator end_iter = end(data);
// 得到 data 的长度
int len_data = distance(begin_iter,end_iter);
cout<<"data : "<<len_data<<endl;
for(auto d : data){
cout<<d<<" ";
}
cout<<endl<<"data : "<<endl;
auto iter = begin(data);
step = 3;
advance(iter,step);
cout<<"the "<<(step+1)<<"th elememt is "<<*iter<<endl;
return 0;
}
结果如下：
因为 forward_list 正向链接元素，所以只能在元素的后面插入或粘接另一个容器的元素，这一点和 list 容器的操作不同，list 可以在元素前进行操作。因为，forward_list 包含成员函数splice_after() 和 insert_after()，用来代替 list 容器的 splice() 和 insert()；顾名思义，元素会被粘接或插入到 list 中的一个特定位置。
当需要在 forward_list 的开始处粘接或插入元素时，这些操作仍然会有问题。除了第一个元素，不能将它们粘接或插入到任何其他元素之前。
这个问题可以通过使用成员函数 cbefore_begin() 和 before_begin() 来解决。它们分别可以返回指向第一个元素之前位置的 const 和 non-const 迭代器。所以可以使用它们在开始位置插入或粘接元素。例如：
forward_list<string> data {"one","null","three"};
forward_list<string> data_ {"null","six","four","zeros"};
forward_list<string>::iterator begin_iter = data.before_begin();
auto iter_ = begin(data_);
int step = 2;
//移到 iter
advance(iter_,step);
//将 "zeros" 移到到 data 的开头
data.splice_after(begin_iter,data_,iter_);
data 的内容为
{"zeros","one","null","three"}
data_ 的内容为
{"null","six","four"}
还有另一个版本的 splice_afler()，它可以将 forward_list<T> 的一段元素粘接到另一个容器中：
forward_list<string> data {"one","null","three"};
forward_list<string> data_ {"null","six","four","five"};
forward_list<string>::iterator begin_iter = data.before_begin();
auto begin_iter_ = begin(data_);
int step = 1;
//移到 begin_iter_
advance(begin_iter_,step);
//end_iter_ 不能移动
forward_list<string>::iterator end_iter_ = end(data_);
//将 "four" 和 "five" 移动到 data 的 "one" 之前
data.splice_after(begin_iter,data_,begin_iter_,end_iter_);
data 的内容为
{"four","five","one","null","three"}
data_ 的内容为
{"null","six"}
另一个版本的 splice_after() 会将一个 forward_list<T> 容器的全部元素粘接到另一个容器中：
forward_list<string> data {"one","null","three"};
forward_list<string> data_ {"null","six","four","five"};
forward_list<string>::iterator begin_iter = data.before_begin();
//将 data_ 全部移动到 data 中
data.splice_after(begin_iter,data_);
data 的内容为
{"null","six","four","five","one","null","three"}
data_ 的内容为
{}
forward_list 和 list —样都有成员函数 sort() 和 merge()，它们也都有 remove()、remove_if() 和unique()，所有这些函数的用法都和 list 相同。
这里也做一些简单的介绍吧。
sort():
sort() 函数定义在头文件 algorithm 中，它要求使用随机访问迭代器，能在指定的迭代器范围内进行排序。
forward_list<int> data {1,5,0,3,2,4};
data.sort();
data 的内容为：
{0 1 2 3 4 5}
实现降序排列：
forward_list<int> data {1,5,0,3,2,4};
data.sort(greater<int> ());
排序后，data 的内容为：
{0 1 2 3 4 5}
简洁版的如下：
forward_list<int> data {1,5,0,3,2,4};
data.sort(greater<> ());
排序后，data 的内容为：
{0 1 2 3 4 5}
merge():
成员函数 merge() 以另一个具有相同类型元素的 forward_list 容器作为参数。两个容器中的元素都必须是升序。参数 forward_list 容器中的元素会被合并到当前的 list 容器中。
forward_list<int> data {1,3,5,7,9};
forward_list<int> data_ {0,2,4,6,8};
data.merge(data_);
data 的内容为：
{0,1,2,3,4,5,6,7,8,9}
在另一个版本的 merge() 函数中，可以提供一个比较函数作为该函数的第二个参数，用来在合并过程中比较元素。
forward_list<string> data { "three","six", "eight"};
forward_list<string> data_ { "seven", "four", "nine"};
auto comp_str = [](const string s1, const string s2){
return s1[0]<s2[0];
};
对 data 排序后
data.sort (comp_str);
data 的内容为：
{"eight","six","three"}
对 data_ 排序后
data_.sort (comp_str);
data_ 的内容为：
{"four", "nine", "seven"}
data 和 data_ 合并后到 data ：
data.merge (data_, comp_str);
data 的内容为：
{"eight", "four", "nine", "six", "seven", "three"}
这里的字符串对象比较函数是由 lambda 表达式定义的，这个表达式只比较第一个字符。比较的效果是，在合并的 list 容器中， "six" 在 "seven" 之前。在上面的代码中，也可以无参调用 merge()，这样 "seven" 会在 "six" 之前，这是一般的排序。
remove():
成员函数 remove() 则移除和参数匹配的元素
forward_list<string> data {"one","two","null","four","five","null","seven"};
// 移除所有为 "null" 的元素
data.remove("null");
data 的内容：
{"one", "two", "four","five","seven"}
remove_if():
成员函数 remove_if() 传入一个一元断言作为参数。一元断言接受一个和元素同类型的参数或引用，返回一个布尔值。断言返回 true 的所有元素都会被移除。
forward_list<string> data {"one","two","null","four","five","null","seven"};
// 移除所有为 "null" 的元素
data.remove_if([](string str){
return str == "null";
});
这里的参数是一个 lambda 表达式，但也可以是一个函数对象。
unique():
成员函数 unique() 可以移除连续的重复元素，只留下其中的第一个。
forward_list<string> data {"one","null","null","four","four","four","seven"};
data.unique();
data 的内容为：
{"one","null","four","seven"}
注意是连续的重复元素，如果是这样的
forward_list<string> data {"one","null","null","four","null","four","four","seven"};
data.unique();
data 的内容为：
{"one","null","four", "null", "four","seven"}
因为它并不是去重，而是去重连续的重复元素，保留第一个。
至此 forward_list 容器的使用就暂告一段落了
