构造函数

	//vector():                                             创建一个空vector
	vector<int> v1 = vector<int>();                         //v1 = []

	//vector(int nSize):                                    创建一个vector,元素个数为nSize
	vector<int> v2 = vector<int>(3);                        //v2 = [0, 0, 0]

	//vector(int nSize,const t& t):                         创建一个vector，元素个数为nSize,且值均为t
	vector<int> v3 = vector<int>(3, 10);                    //v3 = [10, 10, 10]

	//vector(const vector&):                                复制构造函数
	vector<int> v4 = vector<int>(v3);                       //v4 = [10, 10, 10]

	//vector(begin,end):                                    复制[begin,end)区间内另一个数组的元素到vector中
	vector<int> v5 = vector<int>(v4.begin(), v4.end() - 1); //v5 = [10, 10]
	
	vector<vector<int>> v6 = vector<vector<int>>(3, vector<int>(3););    //v6 = [[0, 0, 0][0, 0, 0][0, 0, 0]]

增加函数

	vector<int> v1 = vector<int>(3, 10);           //v1 = [10, 10, 10]
	vector<int> v2 = vector<int>(3);               //v2 = [0, 0, 0]

	//void push_back(const T & x) :                向量尾部增加一个元素X
	v1.push_back(20);                              //v1 = [10, 10, 10, 20]

	//iterator insert(iterator it, const T & x):   向量中迭代器指向元素前增加一个元素x
	v1.insert(v1.begin() + 1, 5);                  //v1 = [10, 5, 10, 10, 20]

	//iterator insert(iterator it, int n, const T & x):向量中迭代器指向元素前增加n个相同的元素x
	v1.insert(v1.end(), 2, 3);                     //v1 = [10, 5, 10, 10, 20, 3, 3]

	//iterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据
	v1.insert(v1.end(), v2.begin(), v2.end());     //v1 = [10, 5, 10, 10, 20, 3, 3, 0, 0, 0]

删除函数

	vector<int> v1 = vector<int>(2, 10);             //v1 = [10, 10]
	v1.push_back(11);                                //v1 = [10, 10, 11]
	v1.push_back(12);                                //v1 = [10, 10, 11, 12]
	v1.push_back(13);                                //v1 = [10, 10, 11, 12, 13]

	//iterator erase(iterator it):                   删除向量中迭代器指向元素
	v1.erase(v1.end() - 1);                          //v1 = [10, 10, 11, 12]

	//iterator erase(iterator first, iterator last): 删除向量中[first, last)中元素
	v1.erase(v1.begin() + 1, v1.end() - 1);          //v1 = [10, 12]

	//void pop_back():                               删除向量中最后一个元素
	v1.pop_back();                                   //v1 = [10]

	//void clear():                                  清空向量中所有元素
	v1.clear();                                      //v1 = []

遍历函数

	vector<int> v1 = vector<int>(1, 10);             //v1 = [10]
	v1.push_back(11);                                //v1 = [10, 11]
	v1.push_back(12);                                //v1 = [10, 11, 12]
	v1.push_back(13);                                //v1 = [10, 11, 12, 13]

	//reference at(int pos):         返回pos位置元素的引用
	int a = v1.at(2);                //a = 12

	//reference front():             返回首元素的引用
	int b = v1.front();              //b = 10

	//reference back():              返回尾元素的引用
	int c = v1.back();               //c = 13

	//iterator begin():              返回向量头指针，指向第一个元素
	int e = *(v1.begin());           //e = 10

	//iterator end():                返回向量尾指针，指向向量最后一个元素的下一个位置
	int f = *(v1.end() - 1);         //f = 13

	//reverse_iterator rbegin():     反向迭代器，指向最后一个元素
	int g = *(v1.rbegin());          //g = 13

	//reverse_iterator rend():       反向迭代器，指向第一个元素之前的位置
	int h = *(v1.rend() - 1);        //h = 10

判断函数

	vector<int> v1 = vector<int>(1, 10);      //v1 = [10]

    //bool empty() const:                     判断向量是否为空，若为空，则向量中无元素
    bool flag = v1.empty();                   //flag = false

大小函数

值得注意的是size和capacity的区别，size是真实元素的所占的空间大小，capacity是整个可容纳的空间大小，如下当对vector删除最后一个元素后，size会减小1，而capacity不会变

	vector<double> v1 = vector<double>(3, 10);   //v1 = [10, 10, 10]
    v1.pop_back();

    //int size() const:                          返回向量中元素的个数
    int size = v1.size();                        //size = 2

    //int capacity() const:                      返回当前向量所能容纳的最大元素值
    int capacity = v1.capacity();                //capacity = 3 (一般不同情况下值不同)

    //int max_size() const:                      返回最大可允许的vector元素数量值
    int max = v1.max_size();                     //max = 1073741823

交换函数

    vector<double> v1 = vector<double>(1, 10);   //v1 = [10]
    vector<double> v2 = vector<double>(1, 55);   //v2 = [55]
    
    //void swap(vector&):                        交换两个同类型向量的数据
    v1.swap(v2);                                 //v1 = [55], v2 = [10]

赋值函数

    vector<int> v1 = vector<int>(3, 10);   //v1 = []
    vector<int> v2 = vector<int>(3, 55);   //v2 = [55, 55, 55]
    
    //void assign(int n,const T& x):       设置向量中前n个元素的值为x
    v1.assign(2, 5);                       //v1 = [5, 5]

    //void assign(const_iterator first,const_iterator last):向量中[first,last)中元素设置成当前向量元素
    v1.assign(v2.begin(), v2.end() - 1);   //v1 = [55, 55]

改变空间

	vector<int> v1 = vector<int>();    //v1 = []
    vector<int> v2 = vector<int>();    //v2 = []

    //改变当前使用数据的大小，如果它比当前使用的大，者填充默认值
    v1.resize(10);                     //v1.size() = 10, v1.capacity() = 10

    //改变当前vecotr所分配空间的大小
    v2.reserve(10);                    //v2.size() = 0, v2.capacity() = 10