C++ STL 顺序容器的使用笔记

容器	说明
vector	可变大小数组。支持快速随机访问，在尾部以外插入或删除可能很慢可变大小数组。支持快速随机访问，在尾部以外插入或删除可能很慢
deque	双端队列。支持快速随机访问，在头尾插入和删除很快
list	双向链表。只支持双向顺序访问。在任意位置插入和删除很快
forward_list	单向链表。只支持单向顺序访问，在任意位置插入和删除很快
array	固定大小数组。支持快速随机访问，不能插入和删除
string	与vector类似，专门用来存储字符。

• string不在本文的范围内
• 由于array不能插入和删除，那么下文的插入函数和删除函数都和array无关

迭代器

forward_list 没有rbegin()、rend()、crbegin()、rend()
before_begin() 和cbefore_begin() 是forward_list独有的

begin()	返回指向容器中第一个元素的迭代器。
end()	返回指向容器最后一个元素所在位置后一个位置的迭代器，通常和 begin() 结合使用。
rbegin()	返回指向最后一个元素的迭代器。
rend()	返回指向第一个元素所在位置前一个位置的迭代器。
cbegin()	和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
cend()	和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
crbegin()	和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
crend()	和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。
before_begin()	返回一个前向迭代器，其指向容器中第一个元素之前的位置。
cbefore_begin()	和 before_begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。

容器容量

• deque 没有capacity() 、reserve()
• list 没有 capacity() 、reserve()
• forward_list 没有 capacity() 、reserve()、size()
• forward_list 和 list 、array 没有 shrink _to_fit()

size()	返回实际元素个数。
max_size()	返回元素个数的最大值。这通常是一个很大的值，一般是 232-1，所以我们很少会用到这个函数。
shrink _to_fit()	将内存减少到等于当前元素实际所使用的大小。
resize(value) resize(newsize,value)	改变实际元素的个数。多则删，少则补，其值为随机 多则删，少则补，其值为val
reserve()	改变实际元素的个数。只增大capacity ,不扩大size
capacity()	返回当前容量。
empty()	判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。

访问容器

• deque 没有 data()
• list 没有 operator[ ]，at()，data()
• forward_list 没有 operator[ ]，at()，front()，data()

operator[]	重载了 [ ] 运算符，可以向访问数组中元素那样，通过下标即可访问甚至修改 vector 容器中的元素。访问不存在的索引的时候，发生越界访问的错误
at()	使用经过边界检查的索引访问元素。访问不存在索引的时候,抛出异常 std::out_of_range
front()	返回第一个元素的引用。
back()	返回最后一个元素的引用。
data()	返回指向容器中第一个元素的指针。

重新赋值

函数原型：
    void assign(_Iter _First, _Iter _Last); //  将值重新变更为_First - Last,不更改capacity
    void assign(_CRT_GUARDOVERFLOW const size_type _Newsize, const _Ty& _Val)  //  将值重新变更为_Newsize个val,不更改capacity
    void assign(initializer_list<_Ty> _Ilist)//  将值重新变更为_Ilist,不更改capacity

插入

往头插入往尾部插入

• vector 不能往头插入push_front、pop_back、emplace_front
• forward_list 没有push_back、pop_back、emplace_back

push_back()	在序列的尾部添加一个元素。
push_front()	在序列的头部添加一个元素。
pop_back()	移除容器尾部的元素。
pop_front()	移除容器头部的元素。
emplace_front()	在容器头部生成一个元素。和 push_front() 的区别是，该函数直接在容器头部构造元素，省去了复制移动元素的过程。
emplace_back()	在容器尾部生成一个元素。和 push_back() 的区别是，该函数直接在容器尾部构造元素，省去了复制移动元素的过程。

往某个迭代器的后面插入

forward_list 为insert_after 、emplace_after()

• insert
  函数原型

iterator insert(const_iterator _Where, _Ty&& _Val) // _Where 位置插入val,并返回val的迭代器
iterator insert(const_iterator _Where, _CRT_GUARDOVERFLOW const size_type _Count, const _Ty& _Val)// _Where 位置插入_count个val,并返回插入的第一个的迭代器
iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) // _Where 位置插入,_First到_Last,并返回插入的第一个迭代器
iterator insert(const_iterator _Where, initializer_list<_Ty> _Ilist) // _Where 位置插入,插入多个,并返回第一个地址 

• emplace()
  函数原型

iterator emplace(const_iterator _Where, _Valty&&... _Val)

删除

forward_list 为erase_after()

• earse
  函数原型

iterator erase(const_iterator _Where) // 返回删除后的第一个元素迭代器
iterator erase(const_iterator _First, const_iterator _Last) // 返回删除后的第一个元素迭代器

• clear() 清空所有元素

交换

swap() 交换两个容器的所有元素。

array 的特别操作

fill(val) 将 val 这个值赋值给容器中的每个元素。

list 和 forward_list 特别操作

forward_list 使用 splice_after()

splice()	将一个 list 容器中的元素插入到另一个容器的指定位置。
remove(val)	删除容器中所有等于 val 的元素。
remove_if()	删除容器中满足条件的元素。
unique()	删除容器中相邻的重复元素，只保留一个。
merge()	合并两个事先已排好序的 list 容器，并且合并之后的 list 容器依然是有序的。
sort()	通过更改容器中元素的位置，将它们进行排序。
reverse()	反转容器中元素的顺序。

• splice() 将一个 list 容器中的元素插入到另一个容器的指定位置。并删除会原来的
  • 函数原型
  • void splice(const const_iterator _Where, list& _Right)
  • void splice(const const_iterator _Where, list&& _Right, const const_iterator _First)
  • void splice(const const_iterator _Where, list&& _Right, const const_iterator _First, const const_iterator _Last)

	std::list<int> list_l{1,2,3,4,5};
	std::list<int> list_r{ 6,7,8,9};
	list_l.splice(list_l.begin(), list_r);
	 list_r.empty()  // TRUE

• remove_if

• auto remove_if(_Pr1 _Pred)
  1. 函数指针 // 一元函数
  2. 利用类里面的operator()

bool even(const int& value) { return (value % 2) == 0; }
int main()
{
std::list<int> list_l{1,2,3,4,5};
list_r.remove_if(even); // list_r 删除偶数 函数指针
}

class testclass_remove
{
public:
	int m_iKey;

	bool operator( ) (int& obj1)
	{
		return obj1 == m_iKey;
	}

	testclass_remove(int iKey) :m_iKey(iKey) {  };
};

int main()
{
std::list<int> list_l{1,6,3,6,5};
list_r.remove_if(testclass_remove(6)); // list_r 删除6 利用类里面的operator()
}

• unique

函数原型
 auto unique() 
 
 template <class _Pr2>
 auto unique(_Pr2 _Pred) //使用二元函数
 	 1. 函数指针
	 2. 利用类里面的operator()

bool pred(int x, int y) {
	return(int(x) == int(y));
};
int main()
{
list_r.assign({ 6,6,7,8,9,1,2,3,6,7,8 });
list_r.unique(pred); // 删除多个
}

• merge

list1.merge(list2); // 自动排序
list1.merge(list2,compare); //指定排序的规则
	 1. 函数指针
	 2. 利用类里面的operator()

int main()
{
	list_r.assign({ 9,10,11 });
	list_l.assign({ 5,6,7,15 });
	list_r.merge(list_l, [](int first, int seconed) {return first < seconed; });
}