// 顺序容器
// 添加元素（array 除外）
// 在尾部创建一个值为 t 或由 args 创建的元素，返回 void，不支持 forward_list
// c.push_back(t)
// c.emplace_back(args)
// 在头部创建一个值为 t 或由 args 创建的元素，返回 void，不支持 vector 和 string
// c.push_front(t)
// c.emplace_front(args)
// 在迭代器 p 指向的元素之前创建一个值为 t 或由 args 创建的元素，返回新添加的元素迭代器
// forward_list有自身独有的 insert 和 emplace
// c.insert(p,t)
// c.emplace(p,args)
// 在迭代器 p 指向的元素之前插入 n 个值为 t 的元素，返回指向新添加的第一个元素的迭代器，若 n 为 0，返回 p
// c.insert(p,n,t)
// 在迭代器 p 指向的元素之前插入迭代器 b,e 指定范围内的元素，返回指向新添加的第一个元素的迭代器，若 n 为 0，返回 p，b,e 不能指向 c 中的元素
// c.insert(p,b,e)
// 在迭代器 p 指向的元素之前插入元素值列表 {li}，返回指向新添加的第一个元素的迭代器，若 n 为 0，返回 p
// c.insert(p,li)
// 向 vector deque string 插入一个元素，会使指向该容器的迭代器，指针，引用失效
// 向 vector string 尾部之外的位置，deque 头尾之外的位置插入元素，都需要移动元素
// 而且向 vector string 添加元素还可能引起对整个对象存储空间的重新分配
//容器访问
//所有容器，包括 array 都有一个 front 成员函数，返回首元素的引用
//除 forward_list 外，所有容器都一个 back 成员函数，返回尾元素的引用
//如果为空，函数行为是未定义的
// string vector deque array 提供下标运算，下标是无符号整数，如果大于等于容器大小，是未定义行为
//at 成员函数类型下标运算，但如果下标越界，会抛出 out_of_range 的异常
// 删除元素（array 除外）
// 删除尾元素，若 c 为空，行为未定义，返回 void，不支持 forward_list
// c.pop_back()
// 删除首元素，若 c 为空，行为未定义，返回 void，不支持 vector 和 string
// c.pop_front()
// forward_list 有自己版本的 erase
// 删除迭代器 p 指向的元素，返回一个指向被删除元素之后的元素的迭代器，若 p 指向尾元素，返回尾后迭代器，若 p 是尾后迭代器，行为未定义
// c.erase(p);
// 删除 b,e 迭代器范围内的元素，返回一个指向最后一个被删除元素之后的元素的迭代器，若 e 是尾后迭代器，则返回尾后迭代器
// c.earse(b,e);
// 删除所有元素，返回 void
// c.clear();
// 删除 deque 首尾位置之外的元素，会使所有迭代器，指针，引用失效
// 删除 vector string 中的元素，指向删除点之后位置的迭代器，指针，引用失效
// forward_list 操作
// 返回指向首元素之前不存在的元素的迭代器，不可以解引用
// c.before_begin()
// 返回指向首元素之前不存在的元素的 const 迭代器，不可以解引用
// c.cbefore_begin()
// 在迭代器 p 之后的位置插入，若 p 是 off of end 迭代器，行为未定义
// c.insert_after(p,t)
// c.insert_after(p,n,t)
// c.insert_after(p,b,e)
// c.insert_after(p,li)
// 在 p 后插入一个用 args 构建的元素，返回这个新元素的迭代器，若 p 是 off of end 迭代器，行为未定义
// c.emplace_after(p,args)
// 删除 p 位置之后的元素或者从 b 之后到（不包括）e之间的元素，返回删除元素之后元素的迭代器，若 p 是尾元素迭代器或 off of end 迭代器，行为未定义
// c.erase(p)
// c.erase(b,e)
// 改变容器大小,会导致迭代器失效
// 调整 c 的大小为 n 个元素，若 n < c.size(),多出的元素被丢弃，若需要添加新元素，对新元素执行值初始化
// c.resize(n)
// 调整 c 的大小为 n 个元素,所有新加元素初始化为 t
// c.resize(n,t)
// 容器操作对迭代器的影响
// 添加元素
// 1>如果是 vector string,且存储空间被重新分配，则指向容器的所有迭代器，指针，引用都会失效
// 如果未重新分配空间，则指向插入位置前的元素迭代器，指针，引用仍有效，之后的均失效
// 2>如果是 deque，在首尾之外位置插入元素，会导致指向容器的所有迭代器，指针，引用失效
// 如果在首尾插入元素，迭代器会失效，指针，引用仍然有效
// 3>如果是 list forward_list ，无影响，均有效
// 删除元素,被删除的元素的迭代器，指针，引用失效
// 1>对于 list forward_list 其他位置的元素，无影响，均有效
// 2>对于 vector string，指向被删元素之前的迭代器，指针，引用仍有效，但尾后迭代器总是失效
// 3>对于 deque，如果在首尾之外的位置删除元素，那么其他位置的迭代器，指针，引用都会失效
// 如果是删除尾元素，则尾后迭代器失效，其他无影响，如果是首元素，也无影响
#include<stdexcept>
#include<string>
#include<iostream>
#include<deque>
#include<list>
#include<vector>
#include<forward_list>
using std::out_of_range;
using std::string;
using std::list;
using std::vector;
using std::forward_list;
using std::deque;
using std::cout;
using std::cin;
using std::endl;
void practice_918();
void practice_919();
void practice_924();
void practice_925();
void practice_926();
void practice_927();
void practice_928(forward_list<string> &fi, string &sa, string &sb);
int main()
{
// practice_918();
// practice_919();
// practice_924();
// practice_925();
// practice_926();
// practice_927();
forward_list<string> fs{"hello", "world", "mamamia", "bye"};
string sa{"wold"};
string sb{"i'm coming"};
practice_928(fs, sa, sb);
return 1;
}
//从流中读入string, 压入 deque 或 list
void practice_918()
{
//写入
string stmp;
deque<string> ds;
list<string> ls;
while(cin >> stmp)
{
// ds.push_back(stmp);
ls.push_back(stmp);
}
//输出
// auto di = ds.cbegin();
auto di = ls.cbegin();
// while(di != ds.cend())
while(di != ls.cend())
{
cout << *di << endl;
++di;
}
}
// 将 list<int> 中元素，按奇偶压入 2个deque
void practice_919()
{
list<int> li{234,1327,8254,9123,823,753,18,37,74,398,1};
deque<int> di_even, di_odd;
auto lii = li.cbegin();
while(lii != li.cend())
{
if(!(*lii % 2 ))
di_even.push_front(*lii);
else
di_odd.push_front(*lii);
++lii;
}
for(auto i : di_even)
cout << "di_even:" << i << endl;
for(auto i : di_odd)
cout << "di_odd:" << i << endl;
}
//顺序容器的访问
void practice_924()
{
deque<int> vi{234,1327,8254,9123,823,753,18,37,74,398,1};
cout << "vi.first = " << vi.front() << endl;
cout << "vi.first = " << *(vi.begin()) << endl;
cout << "vi.first = " << vi[0] << endl;
cout << "vi.first = " << vi.at(0) << endl;
vi.clear();//清空
try
{
cout << "vi.first = " << vi.at(0) << endl;
}
catch(out_of_range err)//捕捉 out_of_range 异常
{
cout << "vi is empty" << endl;
}
cout << "vi.first = " << vi[0] << endl;//未定义行为
}
//删除容器元素
void practice_925()
{
deque<int> vi{234,1327,8254,9123,823,753,18,37,74,398,1};
deque<int>::iterator fi = vi.begin() + 3;
deque<int>::iterator ei = vi.begin() + 5;
auto res = vi.erase(fi,ei);
cout << "result of erase = " << *res << endl;
for(auto i : vi)
cout << "i : vi = " << i << endl;
cout << "******************" << endl;
// 如果 erase 传入2个相等的迭代器，不会删除元素，该迭代器
fi = vi.begin() + 3;
ei = vi.begin() + 3;
res = vi.erase(fi,ei);
cout << "result of erase = " << *res << endl;
for(auto i : vi)
cout << "i : vi = " << i << endl;
cout << "******************" << endl;
// 如果 erase 传入2个尾后的迭代器，不会删除元素，该尾后迭代器
fi = vi.end();
ei = vi.end();
res = vi.erase(fi,ei);
if(res == vi.end())
cout << "result of erase is off of end! " << endl;
for(auto i : vi)
cout << "i : vi = " << i << endl;
}
//删除容器元素
void practice_926()
{
int ai[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
list<int> li(ai, ai + sizeof(ai) / sizeof(int));
vector<int> vi(ai, ai + sizeof(ai) / sizeof(int));
for(auto i : li)
cout << i << " - ";
cout << endl;
for(auto i : vi)
cout << i << " - ";
cout << endl;
cout << "******************" << endl;
//按奇偶删除元素
for(auto ii = li.begin(); ii != li.end();)
{
if(*ii % 2)
++ii;
else
ii = li.erase(ii);
}
for(auto ii = vi.begin(); ii != vi.end();)
{
if(*ii % 2)
ii = vi.erase(ii);
else
++ii;
}
cout << "******************" << endl;
for(auto i : li)
cout << i << " - ";
cout << endl;
for(auto i : vi)
cout << i << " - ";
cout << endl;
}
//从 forward_list 中删除元素
void practice_927()
{
int ai[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
forward_list<int> fi(ai, ai + sizeof(ai) / sizeof(int));
auto fii = fi.begin();
auto bfii = fi.before_begin();
while(fii != fi.end())
{
if(*fii % 2)
{
fii = fi.erase_after(bfii);
}
else
{
bfii = fii;
++fii;
}
}
cout << "******************" << endl;
for(auto i : fi)
cout << i << " - ";
cout << endl;
}
//在 forward_list 中查找 sa,将sb 插入其后，若找不到 sa,将sb 插到末尾
void practice_928(forward_list<string> &fi, string &sa, string &sb)
{
auto fii = fi.begin();
auto bfii = fi.before_begin();
while(fii != fi.end())
{
if(*fii == sa)
{
fii = fi.insert_after(fii,sb);
break;
}
else
{
bfii = fii;
++fii;
}
}
if(fii == fi.end())
fi.insert_after(bfii, sb);
cout << "******************" << endl;
for(auto i : fi)
cout << i << " - ";
cout << endl;
}
