void test()
{
vector<int> number = {1, 2, 3, 4, 5, 6, 7, 8, 9};
display(number);
cout << "number.size() = " << numbers.size() << endl;//9
cout << "number.capacity() = " << numbers.capacity() << endl;//9


cout << endl << "在容器尾部进行插入: " << endl;
number.push_back(10);
number.push_back(11);
display(number);
cout << "number.size() = " << number.size() << endl;//11
cout << "number.capacity() = " << number.capacity() << endl;//18

cout << endl << "在容器vector中间进行插入: " << endl;
auto it = number.begin();
++it;
++it;
number.insert(it, 22);
display(number);
cout << "*it = " << *it << endl;
cout << "number.size() = " << number.size() << endl;//12
cout << "number.capacity() = " << number.capacity() << endl;//18

numbers.insert(it, 7, 100);//因为插入个数不确定，有可能底层已经发生了扩容
display(numbers);
cout << "*it = " << *it << endl;
cout << "numbers.size() = " << numbers.size() << endl;//19
cout << "numbers.capacity() = " << numbers.capacity() <<endl;//24

//正确办法是重置迭代器的位置
vector<int> vec{51, 52, 53, 56, 57, 59};
numbers.insert(it, vec.begin(), vec.end());//继续使用该迭代器就会出现问题（内存错误）
display(numbers);
cout << "*it = " << *it << endl;
cout << "numbers.size() = " << numbers.size() << endl;
cout << "numbers.capacity() = " << numbers.capacity() << endl;

//解决方案：每次在插入元素的时候，可以将迭代器的位置进行重置更新，避免因为底层扩容，迭代器还指向老
//的空间而出现问题
vector<int> vec{51, 52, 53, 56, 57, 59};
it = number.begin();//重新置位
++it;
++it;
numbers.insert(it, vec.begin(), vec.end());//继续使用该迭代器就会出现问题（内存错误）
display(numbers);
cout << "*it = " << *it << endl;
cout << "numbers.size() = " << numbers.size() << endl;
cout << "numbers.capacity() = " << numbers.capacity() << endl;
}

因为 vector 的 push _ back 操作每次只会插入一个元素，所以可以按照统一的形式 2 * capacity() ，但是 insert 的时候，插入的元素个数是不定的，所以就不能一概而论。这里可以分别讨论一下，我们设置capacity () = n , size () = m , insert 插入的元素个数为 t个：

如果 t < n - m ，新插入元素的个数比剩余空间小，这个时候就无需扩容，所以直接插入;

如果 n - m < t < m ，就按照 m 的 2 倍去进行扩容，新的空间就是 2 * m ；如果n - m < t < n 且 t > m , 就按照 t + m 去进行扩容；

如果 t > n 时，依旧按照 t + m 去进行扩容 ；

这就是vector 进行 insert 扩容的原理（这个原理可以了解一下，主要是为了告诉大家不

是两倍扩容）。

//删除指定迭代器位置的元素
iterator erase(iterator position);
//删除一个迭代器范围的元素
iterator erase(iterator first, iterator last);

对于 vector 而言，会导致删除迭代器之后的所有元素前移，从而导致删除元素之后的所有迭代器失效（迭代器的位置没有改变，但是因为元素的移动，导致迭代器指向的不是删除之前的元素，所以失效）；deque 比 vector 复杂，要看 pos 前后的元素个数来决定，deque 的 erase 函数可以看 STL 源码，需要看删除位置与 size () 的一半的大小，然后看是挪动前一半还是后一半，尽量减少挪动的次数；list 会删除指向的元素，从而导致指向删除元素的迭代器失效。

这里以 vector 的 erase 为例，看看其删除元素的操作与删除后的效果。

//题意：删除vector中所有值为4的元素。
vector<int> vec = {1, 3, 5, 4, 4, 4, 4, 7, 8，4, 9};
for (vector<int>::iterator it = vec.begin(); it != vec.end(); ++it)
{
    if(4 == *it)
    {
        vec.erase(it);
    }
}

//发现删除后有些4没有删除掉，可以推测出是什么原因吗？是那些4没有删除呢？
//正确解法：
for (auto it = vec.begin(); it != vec.end();)
{ 
    if (4 == *it)
    {
        vec.erase(it);//此处可以使用it接收erase的结果，更通用一些，即：it = vec.erase(it);
    }
    else
    {
        ++it;
    }
}

其他操作

//1、清除容器中的所有元素(三个序列式容器都有)
void clear();

//2、获取元素个数(三个序列式容器都有)
size_type size() const;

//3、获取容量大小（只有vector有）
size_type capacity() const;

//4、回收多余的空间，使得元素的个数与容量大小对应，不存在没有使用的空间（vector与deque有这个函数）
void shrink_to_fit();

//5、交换两个相同容器中的元素(三个序列式容器都有)
void swap( vector& other);
vector<int> number1 = {1, 2, 3};
vector<int> number2 = {10, 20, 30};
number1.swap(number2);//之后number1中的内容与number2中的内容做了交换

//6、更改容器中元素个数(三个序列式容器都有)
//以vector为例，执行resize时候，如果count < size(),就将多余的元素删除；如果count > size(),就在//之前的元素后面执行insert添加元素（没有指定就添加默认值）,元素的个数在改变的同时，容量也在发生改变 //（上一次的两倍或者本次元素个数）
void resize( size_type count, T value = T() );
void resize( size_type count);
void resize( size_type count, const value_type& value);

//7、获取第一个元素(三个序列式容器都有)
reference front();
const_reference front() const;

//8、获取最后一个元素(三个序列式容器都有)
reference back();
const_reference back() const;

//9、C++11增加的可变参数模板的几个函数
//在容器的尾部就地构造一个元素
template< class... Args >
void emplace_back( Args&&... args);
vector<Point> vec;
vec.emplace_back(1, 2);//就地将(1, 2)构建为一个对象存放在vector的尾部，减少拷贝或者移动

list的特殊操作

排序函数sort

void sort();//默认以升序进行排序，其实也就是，使用operator<进行排序
template< class Compare >
void sort(Compare comp);//其实也就是传入一个具有比较的类型，即函数对象
template <typename T1, typename T2>
struct Compare
{
    bool operator()(const T1 &a, const T2 &b) const
    {
        return a < b;
    }
};

移除重复元素u n i q u e

void unique();
size_type unique();

逆置链表中的元素r e v e r s e

void reverse();
void reverse() noexcept;

合并链表的函数m e r g e

//合并两个链表（other既可以是左值也可以是右值）
void merge( list& other );
void merge( list&& other );
template <class Compare>
void merge( list& other, Compare comp );
template <class Compare>
void merge( list&& other, Compare comp );

从一个链表转移元素到另一个链表s p l i c e

//移动other链表到另一个链表的某个指定位置前面
void splice(const_iterator pos, list& other);
void splice(const_iterator pos, list&& other);

//移动other链表中的某个元素到另一个链表的某个指定位置前面
void splice(const_iterator pos, list& other, const_iterator it);
void splice(const_iterator pos, list&& other, const_iterator it);

//移动other链表的一对迭代器范围元素到另一个链表的某个指定位置前面
void splice(const_iterator pos,list& other, const_iterator first, const_iterator last);
void splice(const_iterator pos,list&& other,const_iterator first, const_iterator last);