[C++]vector使用总结

什么是Vector?

向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。

容器特性

1.顺序序列

顺序容器中的元素按照严格的线性顺序排序。可以通过元素在序列中的位置访问对应的元素。
2.动态数组

支持对序列中的任意元素进行快速直接访问，甚至可以通过指针算述进行该操作。查询和随机存储的时间复杂度为O(1)。操供了在序列末尾相对快速地添加/删除元素的操作。
3.能够感知内存分配器的（Allocator-aware）

容器使用一个内存分配器对象来动态地处理它的存储需求。

4.缺点

除序列末尾，插入和删除操作效率较低，不适合频繁的插入和删除。当超过已有容器容量大小，需重新分配一块连续存储空间，操作耗时，最好提前预留好适量容量。

使用和常用函数

使用需包含头文件

// A code block
#include <vector>;

构造函数

1.vector( const Allocator& = Allocator() )
Allocator是一个缺省参数，它是用于指定要使用的空间配置器的。基本不用管这个参数，除非是我们自己实现了一个空间配置器，然后希望使用我们自己写的空间配置器。
该构造函数用于事先不知道需要存放元素个数下情况使用。

// A code block
#include <vector>
using namespace std;
vector<int> v1;
v1.push_back(1);

2.vector( size_type n,constT& value = T(), const Allocator& = Allocator() );
size_type n :元素个数
constT& value = T()：初始值，可以缺省。若缺省，类型必须为内置类型或具有默认构造函数的数据类型，否则报错。
Allocator：缺省参数（同上）

// A code block
vector<int> v2（5）;
vector<int> v3（5，-1）;

3.template vector ( InputIterator first, InputIterator last, const Allocator& = Allocator() );
调用giant函数传入两个参数，分别为一段序列的起始地址/迭代器和结束地址/迭代器。该构造函数根据一段序列来创建一个vector,并使用该序列里的内容来初始化。

// A code block
int  arr[5] ={1,2,3,4,5}
vector<int> v4（arr,arr+5）;//使用起始和结束地址
vector<int> v5（v4.begin()，v4.end()-1）;//使用迭代器

4.vector ( const vector<T,Allocator>& x );
拷贝构造函数

// A code block
vector<int> v6（v5）;

插入函数

1.void push_back(const value_type& _Val)
向尾部插入一个元素
2.template <class… Args> void emplace_back (Args&&… args);
向尾部插入一个元素（原地构造临时对象）（推荐使用）

// A code block
vector<string> v1;
v1.push_back("hello");//调用移动拷贝运算符，直接复制数据到vector
v1.push_back(string("hello"));//先构造字符串“hello”,再移动到vector
v1.emplace_back("hello");//直接在vector中原地构造字符串“hello”,效率比上面高
string str {"alleged"};
v1.emplace_back(str, 2, 3);//可以直接使用该类的构造函数，尤其适合自定义类和数据结构的插入

emplace_back() 和 push_back 的区别 3.iterator insert(const_iterator position,const value_type& _Val)
在指定迭代器前插入一个元素，返回新元素位置迭代器 const_iterator position：待插入的位置 const value_type& _Val：插入的元素
4.iterator insert(const_iterator position,size_type n,const value_type& _Val) 在指定迭代器前插入n个相同元素，返回第一个新元素位置迭代器 5.template
iterator insert(const_iterator position,InputIterator first, InputIterator last)
在指定迭代器前插入一段序列，分别为一段序列的起始地址/迭代器和结束地址/迭代器，返回新序列开始迭代器
6.iterator insert(const_iterator position,value_type&& _Val)
在指定迭代器前插入一个元素引用，返回新元素位置迭代器
7.iterator insert(const_iterator position,initializer_list il) 在指定迭代器前插入一个初始化列表，返回初始化列表第一个元素位置迭代器

// A code block vector
vector<std::string> words { "one","three","eight"};
iter = words.insert(std::end(words), {std::string {"twelve"},std::string {"thirteen"}});

注意：
vector 的成员函数 insert()，需要一个标准的迭代器来指定插入点；它不接受一个反向迭代器——这无法通过编译

删除函数

1.iterator erase(iterator it)
删除vector中迭代器指向元素,返回下一个元素位置的迭代器，如果为最后一个元素，返回vector.end()所指向的位置
2.iterator erase(iterator first,iterator last)
删除vector中一段序列中所有元素,返回删除后下一个元素位置的迭代器
3.void pop_back()
删除vector中最后一个元素
4.void clear()
清空vector中所有元素
注意：
这里有个大坑，clear()并不会真正释放内存， 如果vector的元素是一些object, 则它将为当前储存的每个元素调用它们各自的析构函数(destructor). 然而, 如果vector储存的是指向对象的指针, 此函数并不会调用到对应的析构。在第二种情况下, 为了完全删除vector中的元素则应使用一个类似于下的循环:

std::vector<SomeObject*> aVector;
    //The elements of the vector are created with the operand 'new' at some point in the program
    [...]
    for(int i=0 ; i<aVector.size() ; i++)
        delete aVector[i];
    aVector.clear();

然后它只会将size大小设为0，但它的容量(capacity)却并不发生变化, vector本身并不释放任何内存.
如果你想同时做到清空vector的元素和释放vector的容量, 你可以使用swap技巧。
vector(v).swap(v);
5.remove()
这是个模板算法，不属于vector的成员函数，需包含头文件#include ,可以删除匹配特定值的一段元素

std::vector<std::string> words { "one", "none","some", "all”, "none", "most","many"};
auto iter = std::remove(std::begin(words), std::end(words), "none");
words.erase(iter, std::end(words));

但它不能删除容器中的元素。remove() 移除元素的方式和从字符串中移除空格的方式相似，都是通过用匹配元素右边的元素来覆盖匹配元素的方式移除元素。常和erase()一起搭配使用。
remove算法原理：

访问函数

1.vec.at(int pos)
返回pos位置元素的引用
2.vec.front()
返回首元素的引用
3.vec.back()
返回尾元素的引用
4.iterator vec.begin()
返回向量头指针，指向第一个元素
5. iterator vec.end()
6. 返回向量尾指针，指向向量最后一个元素的下一个位置
7.reverse_iterator vec.rbegin()
反向迭代器，指向最后一个元素
8.reverse_iterator vec.rend()
反向迭代器，指向第一个元素之前的位置

改变容器大小函数

1.vector.resize(int n)
2.vector.reserve(int n)
vector 的reserve增加了vector的capacity，但是它的size没有改变！而resize改变了vector的capacity同时也增加了它的size！
原因如下：
reserve是容器预留空间，但在空间内不真正创建元素对象，所以在没有添加新的对象之前，不能引用容器内的元素。加入新的元素时，要调用push_back()/insert()函数。
resize是改变容器的大小，且在创建对象，因此，调用这个函数之后，就可以引用容器内的对象了，因此当加入新的元素时，用operator[]操作符，或者用迭代器来引用元素对象。此时再调用push_back()函数，是加在这个新的空间后面的。
建议：如果已知容器容量大小，可实现用reserve预留空间，防止vector自动初始化空间不足，导致二次重分配空间。

其他函数

1.bool empty() const
判断向量是否为空，若为空，则向量中无元素
2.int size() const
返回向量中元素的个数
3.int max_size() const
返回最大可允许的vector元素数量值
4.void swap(vector&)
交换两个同类型向量的数据5
5.void assign(int n,const T& x)
设置向量中第n个元素的值为x
6.void assign(const_iterator first,const_iterator last)
向量中[first,last)中元素设置成当前向量元素

小技巧

vector去重两种方法

1.使用set容器

// A code block
#include <iostream>
#include <vector>
#include <set>
using namespace std;
int main()
{
	int arr[] = {1,1,1,2,2,3,3,4,4}
	int len = sizeof(arr)/sizeof(int);
	vector<int> vec(arr,arr+len);
	set<int> s(vec.begin(),vec.end());
	vec.assign(s.begin(),s.end());
	for(auto item:vec)
	{
		cout <<item<<endl;
	}
	return 0;
}

2.结合sort和unique函数
unique()函数将相邻且重复的元素放到vector的尾部 然后返回指向第一个重复元素的迭代器再用erase函数擦除从这个元素到最后元素的所有的元素。

// A code block
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
 int arr[] = {1,1,1,2,2,3,3,4,4}
 int len = sizeof(arr)/sizeof(int);
 vector<int> vec(arr,arr+len);
 sort(vec.begin(),vec.end());
 vec.erase(unique(vec.begin(),vec.end()),vec.end());
 for(auto item:vec)
 {
  cout <<item<<endl;
 }
 return 0;
}