建设部网站安全考核证书查询北京公司注册查询
目录
默认成员函数
迭代器
vector的扩容：
reserve:
resize:
at:
增删：
push_back和pop_back
insert和erase
查改：
find:
编辑
sort:
在C语言中，想要存储非连续的数据，通常会用数组(array)，例如int arr[20]，arr中就可以存储20个int类型数据，但arr这个数组它的上限就永远是20，不会动态增长。
在C++中，STL中的vector容器就很好的弥补了这点，它是一个可以动态增长的顺序表容器，本篇文章会说明vector最常用的十几种接口函数
默认成员函数
vector的默认成员函数有4个，分别是构造函数，拷贝构造函数，析构函数和赋值运算符重载函数
vector<int> v1;//默认构造函数
vector<int> v2(114, 514);//将114个514存入v2(不常用，了解即可)vector<int> v3(v2);//拷贝构造函数vector<int> v4;
v4 = v3;//赋值运算符重载和string的默认成员函数大差不差
那么string和vector<char>有什么区别呢？
他们两者都是用来存储字符的数组，但string一般是用来存储一串连续的数据，而vector一般用来存储不连续的多个数据
例如，当你想要存储40个人的身份证号时，可以用40个string对象分别存储，而存储40个人的年龄时，就可以用一个vector来存储
这也说明了为什么vector里没有<<和>>，append这种运算符重载函数，因为vector不需要，能用到这两种运算符重载的数据都会去选择string
和string一样，vector也可以尾插
vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);上述代码就是将1,2,3,4依次尾插到v1中
迭代器
对于vector，有3种方法可以输出其中的数据
1.operator[]+size()
vector也是支持[]重载的
再加上size()函数用来读取vector中的数据总个数
vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
for (int i = 0; i < v1.size(); i++)
{cout << v1[i] << " ";
}输出结果：
2.迭代器
对于每个STL中的容器都有迭代器，vector当然也不例外
迭代器一共有三种类型，分别是普通迭代器，反向迭代器和只读(const)迭代器
普通迭代器：
vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
vector<int>::iterator it = v1.begin();
while(it != v1.end())
{cout << *it << " ";it++;
}输出结果和上面的一样
vector<int>::iterator 就是int类型的vector的迭代器类型
begin和end分别返回的是该对象起始位置和结束位置的迭代器
3.范围for
vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
for(auto e : v1)
{cout << e << " ";
}输出和上面的一样
范围for本质上还是迭代器，auto e中的auto就会被替换成后面v1的迭代器类型，即vector<int>::iterator，并赋值成v1.begin()，它会自动加加，直到==v1.end()。
迭代器不仅可以正向遍历，还可以反向遍历
反向迭代器：
rbegin和rend也就是reverse_begin和reverse_end的意思，即翻转之后的begin和end
但可以看到，他们的返回值类型都是reverse_iterator，即翻转后的迭代器类型
所以直接将一个普通的迭代器变量复制成rbegin会报错
这时候就要用到上面提到的reverse_iterator
vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
vector<int>::reverse_iterator rit = v1.rbegin();//反向迭代器
while(rit != v1.rend())
{cout << *rit << " ";rit++;
}输出结果：
只读(const)迭代器:
void printv(const vector<int>& v)
{vector<int>::const_iterator cit = v.begin();while(cit != v.end()){cout << *cit << " ";cit++;}
}
int main()
{vector<int> v1;//默认构造函数v1.push_back(1);v1.push_back(2);v1.push_back(3);v1.push_back(4);printv(v1);}就好比上面这个程序，我的printv函数的参数是const vector<int>&类型，这是因为一般来说传参都喜欢用&用来提高效率，而为了防止改变原数据，又会在前面加上const，在这种情况下， 想要用普通迭代器的话会报错，因为这就属于权限放大了，由const变成了非const(具体可以去搜权限放大缩小问题)。
对于这种情况，就需要用到const_iterator
除此之外，迭代器的反向和只读特性还可以同时拥有，即const_reverse_iterator，只读反向迭代器
假设有个vector对象是vec：
vector的扩容：
和string一样，vector也有size和capacity接口，分别用来调用该对象所存储的数据个数和容量
vector<int> v1;//默认构造函数
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
cout << v1.size() << endl << v1.capacity() << endl;输出结果：
也就是说size是5，capacity是8，那么vector的capacity增长策略是怎么样的呢？
void Test()
{size_t sz;vector<int> v;sz = v.capacity();cout << "capacity的变化:\n";for (int i = 0; i < 100; ++i){v.push_back(i);if (sz != v.capacity()){sz = v.capacity();cout << "capacity changed: " << sz << '\n';}}
}该函数用于测试逐个插入数据直到100，capacity的变化
输出结果(VS环境)：
可以看到规律大概是1.5倍，只不过会向下取整
但如果换到别的环境下测试，例如Linux和GCC编译器：
现在的增长策略又是2倍了
不同环境下的增长策略不一样，那么到底是1.5倍的策略更好还是2倍的策略更好？
如果把插入的数据从100改到1067,就会发现2倍的扩容会浪费更多的空间
但是2倍的又比1.5倍的扩容次数要少，所以说各有千秋
1.5倍不浪费空间，但浪费时间
2倍不浪费时间，但浪费空间
reserve:
前面说到不断的开辟更大的空间会消耗很多时间，那有没有什么办法可以提高效率呢？
void Test()
{size_t sz;vector<int> v;v.reserve(1066);//在插入数据之前开辟好1066个空间sz = v.capacity();cout << "capacity的变化:\n";for (int i = 0; i < 1066; ++i){v.push_back(i);if (sz != v.capacity()){sz = v.capacity();cout << "capacity changed: " << sz << '\n';}}
}输出结果：
可以看到，这次capacity就没有变化了
这是因为上面代码在原来的基础上加了一行v.reserve(1066)，就直接把对象v的容量一次性扩到了1066，自然就不需要再额外扩容了
resize:
reserve是可以开辟到更大的容量，而resize是将值增长或减少到一个值，也就是val，如果不给，默认就是0
若n比原本的size大：
void print(const vector<int>& v)
{for (int i = 0; i < v.size(); i++){cout << v[i] << " ";}cout << endl;
}
int main()
{vector<int> v;for (int i = 0; i < 5; i++){v.push_back(i);}v.resize(10);print(v);cout << v.capacity() << endl;v.resize(15,114);print(v);cout << v.capacity() << endl;return 0;
}输出结果:
一开始v有5个数据，后面resize到了10个，而且没有指定val的值，所以默认就是0，第一行的后面就多了5个0，第二行输出的是当前capacity，可以看到是10
后面就resize成了15，但这次指定了val是114，所以第三行输出后面就又跟了5个114，第四行输出的是当前capacity，可以看到是20。即：若capacity超出，也会自动扩容capacity
若n比原来的size小：
void print(const vector<int>& v)
{for (int i = 0; i < v.size(); i++){cout << v[i] << " ";}cout << endl;
}
int main()
{vector<int> v;for (int i = 0; i < 15; i++){v.push_back(i);}v.resize(10);print(v);cout << v.capacity() << endl;v.resize(5);print(v);cout << v.capacity() << endl;return 0;
}输出结果：
可以看到，当n小于当前size时，会直接删除n后面的数据，但capacity不会缩小
at:
vector<int> v;
for (int i = 0; i < 10; i++)v.push_back(i);
v[10] = 2;上面所示代码中，v有10个元素，下标到9，但我调用了v[10]，这里就非法访问了
但如果用at接口呢
vector<int> v;
for (int i = 0; i < 10; i++)v.push_back(i);
v.at(10) = 2;
可以看到，虽然也报了错，但这是报的异常，只要补异常就不会报错了
增删：
push_back和pop_back
push_back一开始已经讲过，就是尾插数据
pop_back是尾删数据
void print(const vector<int>& v)
{for (int i = 0; i < v.size(); i++){cout << v[i] << " ";}cout << endl;
}
int main()
{vector<int> v;v.push_back(1);v.push_back(2);v.push_back(3);v.push_back(4);v.pop_back();print(v);return 0;
}输出结果：
insert和erase
可以发现vector的insert和string的不一样，vector的第一个参数是传的迭代器
void print(const vector<int>& v)
{for (int i = 0; i < v.size(); i++){cout << v[i] << " ";}cout << endl;
}
int main()
{vector<int> v;v.push_back(1);v.push_back(2);v.push_back(3);v.push_back(4);v.insert(v.begin(), 0);//头插一个元素v.insert(v.begin(),-1);//头插一个元素v.insert(v.end(), 5);//尾插一个元素print(v);return 0;
}输出结果：
可以看到，erase传的也是迭代器
因为没有缺省值，所以就不能再像string一样直接传无参了
void print(const vector<int>& v)
{for (int i = 0; i < v.size(); i++){cout << v[i] << " ";}cout << endl;
}
int main()
{vector<int> v;v.push_back(1);v.push_back(2);v.push_back(3);v.push_back(4);v.insert(v.begin(), 0);//头插一个元素v.insert(v.begin(),-1);//头插一个元素v.insert(v.end(), 5);//尾插一个元素v.erase(v.begin());//头删v.erase(v.end());//尾删print(v);return 0;
}可以看到先头删再尾删，看着没有问题
但实际上会出现内存错误
这是因为end()迭代器是返回的最后一个数+1的位置，这个位置是没有元素的
所以要尾删的话，需要传end()-1
void print(const vector<int>& v)
{for (int i = 0; i < v.size(); i++){cout << v[i] << " ";}cout << endl;
}
int main()
{vector<int> v;v.push_back(1);v.push_back(2);v.push_back(3);v.push_back(4);v.insert(v.begin(), 0);//头插一个元素v.insert(v.begin(),-1);//头插一个元素v.insert(v.end(), 5);//尾插一个元素v.erase(v.begin());//头删v.erase(v.end()-1);//尾删print(v);return 0;
}输出结果：
查改：
find:
虽然vector里没有find函数(string里有)，但std,即全局中，有find函数，这是算法里的，包含于<algorithm>头文件(这个单词翻译过来就是算法的意思)
可以看到三个形参中，前两个形参是迭代器类型，分别表示起始位置和结束位置，需要特别注意的是，只要是这种传迭代器区间的形参，都传的是左闭右开区间(包括下面要讲到的sort函数)，第三个形参则是要找的数据
void print(const vector<int>& v)
{for (int i = 0; i < v.size(); i++){cout << v[i] << " ";}cout << endl;
}int main()
{vector<int> v;for (int i = 0; i < 10; i++){v.push_back(i);}vector<int>::iterator pos = find(v.begin(), v.end(), 5);//左闭右开区间if(pos != v.end())//用来判断是否找到{v.erase(pos);}print(v);return 0;
}输出结果：
那么代码中下面的if判断是怎么来判断是否找到的呢？
这是find函数的具体实现，可以发现，若这个左闭右开区间内没有找到，最后返回是last，也就是第二个参数(开区间的迭代器)，所以pos只要不等于开区间的迭代器，就代表找到了
sort:
本篇就先只介绍第一行的sort，两个形参也是左闭右开的迭代器类型(sort函数底层是用快排实现的)
void print(const vector<int>& v)
{for (int i = 0; i < v.size(); i++){cout << v[i] << " ";}cout << endl;
}int main()
{vector<int> v;v.push_back(3);v.push_back(1);v.push_back(6);v.push_back(8);v.push_back(7);v.push_back(9);v.push_back(4);v.push_back(6);sort(v.begin(), v.end());//传左闭右开区间print(v);return 0;
}输出结果：
