Vector容器（黑马程序员）
目录
- vector容器，STL中最常用的容器之一
-
- 1 vector基本概念
-
- 普通数组一旦分配内存，容量就被固定了，无法扩展。
- 2 vector的构造函数
- 3 vector赋值操作
- 4 vector存放内置数据类型
-
- 注意STL中每个容器使用前都得包含它的头文件
- STL自带的遍历算法： `for_each`
- 5 vector存放自定义数据类型
-
- 每个容器都有自己专属的迭代器。同一个容器，迭代器的类型与容器的数据类型相匹配
- 总结：<>里是什么数据类型，*it解出来的就是什么数据类型。it的本质是个指针
- 6 Vector容器嵌套容器
-
-
- vector中嵌套vector。 相当于数组中嵌套数组,也就是个二维数组
-
- 7 vector容量和大小
-
- 总结
- 8 vector插入和删除
- 9 vector数据存取
-
- vector容器有 []、迭代器、at（）三种访问方式
- 10 vector互换容器
-
- 巧用容器互换可以收缩内存空间
- 11 vector预留空间
-
- 为什么要减少动态扩展次数，因为动态扩展虽然快，但仍然很麻烦。而且不要随意的去开辟内存空间，操作内存空间还是比较危险的。
- 注意：不能初始化≠不能赋值。初始化和赋值是两种完全不同的操作
vector容器，STL中最常用的容器之一
视频与文档链接
1 vector基本概念
功能：
- vector数据结构和数组非常相似，也称为单端数组
普通数组一旦分配内存，容量就被固定了，无法扩展。
vector与普通数组区别：
- 不同之处在于数组是静态空间，而vector可以动态扩展
动态扩展：
- 并不是在原空间之后续接新空间，而是找更大的内存空间(STL中有专门的算法去找这个内存空间），然后将原数据拷贝新空间，释放原空间
- vector容器前端封闭，一般都是在尾部插入数据：push_back和删除数据：pop_back
- v.rend()：这个迭代器指向第一个元素的前以为
- v.begin()：常用的vector迭代器，指向第一个第一个元素
- v.end():常用的vector迭代器，指向最后一个元素的后一位
- v.rbegint():这个迭代器指向最后一个元素
- vector容器的迭代器支持随机访问，可以一下跳好几个元素
2 vector的构造函数
函数原型：
-
vector//采用模板实现类实现，默认构造函数v; -
vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。
// 注意：这里可以取到v.begin()的值，但取不到v.end()的值
// v.end(）不是指向最后一个元素 -
vector(n, elem);//构造函数将n个elem拷贝给本身。
// 不写elem的话，则是传n个0进去 -
vector(const vector &vec);//拷贝构造函数。
#include
using namespace std;
#include
#include
void test01();
// 打印函数
void printVector(vector v1) {
for (vector::iterator it = v1.begin(); it != v1.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
// vector 构造函数
// 1.默认构造（无参构造）
void test01() {
vector v;
for (int i = 0; i < 10; i++) {
v.push_back(i);
}
cout << "默认构造：";
printVector(v); cout << endl;
// 2.通过区间方式
vectorv2(v.begin(), v.end() - 2);
cout << "通过区间的方式构造:";
printVector(v2); cout << endl;
// 3.n个元素方式
vectorv3(10, 55);
cout << "传入n个元素的方式构造:";
printVector(v3); cout << endl;
// 4.拷贝构造方式
vectorv4(v2);
cout << "v4拷贝构造v2：";
printVector(v4); cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
3 vector赋值操作
功能描述：
- 给vector容器进行赋值
函数原型：
-
vector& operator=(const vector &vec);//重载等号操作符 -
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。 -
assign(n, elem);//将n个elem拷贝赋值给本身。
#include
using namespace std;
#include
#include
void test01();
// 打印函数
void printVector(vector v1) {
for (vector::iterator it = v1.begin(); it != v1.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
// vector 的赋值操作
void test01() {
vectorv1;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
}cout << "v1：";
printVector(v1); cout << endl;
1.重载等号赋值
vectorv2;
v2 = v1;
cout << "v2:";
printVector(v2); cout << endl;
// 2.assign函数（区间赋值）
vectorv3;
v3.assign(v1.begin(), v1.end());
cout << "v3:";
printVector(v3);
cout << endl;
// 3.assign函数（n个元素赋值)
vectorv4;
v4.assign(10, 66);
cout << "v3:";
printVector(v4); cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}
总结： vector赋值方式比较简单，使用operator=，或者assign都可以
4 vector存放内置数据类型
容器： vector
算法： for_each
迭代器： vector
<>里写我们要操作的数据类型
注意STL中每个容器使用前都得包含它的头文件
示例：
#include
using namespace std;
#include
#include
void Myprint(int n) {
cout << n << endl;
}
void test01() {
// 创建一个vector容器，数组
vector v;
// 向vector容器中插入数据（尾插）
v.push_back(10);
v.push_back(10);
v.push_back(10);
v.push_back(10);
// 通过迭代器访问容器里的元素
// 注意迭代器的写法
vector::iterator itBegin = v.begin();
vector::iterator itEnd = v.end();
第一种遍历方式
//while (itBegin != itEnd) {
// cout << *itBegin << endl;
// itBegin++;
//}
第二种遍历方式
//for(vector::iterator it=v.begin(); it != v.end(); it++) {
// cout << *it << endl;
//}
// 第三种遍历方式，利用STL中提供的遍历算法。
// 回调技术
for_each(v.begin(), v.end(), Myprint);
}
int main() {
test01();
cin.get();
return 0;
}
STL自带的遍历算法： for_each
// 首先包含算法头文件
#include
void Myprint(int n) {
cout << n << endl;
}
for_each(v.begin(), v.end(), Myprint);
为什么第三个参数用函数名呢？这是利用了回调技术，这个函数一开始不调用，直到for_each遍历的期间才调用这个函数。
底层原理如下：
5 vector存放自定义数据类型
每个容器都有自己专属的迭代器。同一个容器，迭代器的类型与容器的数据类型相匹配
- vector < Person >::iterator it = v.begin();
it是指向Person类的指针，*it就是Person类。
引用Person中的成员：it->m_Age 或者 (*it).m_Age
- vector
it是指向Person *的指针。*it代表的是Person *（Person类型的指针）!！不是Person类
( *（*it）)才代表Person类。
引用Person中的成员：（*it）->m_Age 或者 ( * (*it)).m_Age
- vector::iterator it = v.begin();
it 是指向int型的指针，*it代表一个int型数据
总结：<>里是什么数据类型，*it解出来的就是什么数据类型。it的本质是个指针
示例：
#include
using namespace std;
#include
#include
#include
/*学习目标：容器中嵌套容器，我们将所有数据进行遍历输出
*/
class Person {
public:
Person(string name, int age) :m_name(name), m_age(age) {}
string m_name;
int m_age;
};
void test01(){
vectorv;
Person p1("Tom", 36);
Person p2("FAZA", 555);
Person p3("NAVI", 666);
Person p4("RNG", 78);
Person p5("EDG", 777);
// 向容器中添加数据
// 尾插
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
v.push_back(p5);
v.push_back(p1);
// 遍历容器中的数据
for (vector::iterator it = v.begin(); it != v.end(); it++) {
cout <<"姓名："<< it->m_age <<" "
<<"年龄：" << (*it).m_name<v;
Person p1("Tom", 36);
Person p2("FAZA", 555);
Person p3("NAVI", 666);
Person p4("RNG", 78);
Person p5("EDG", 777);
//向容器中添加数据
// 尾插
v.push_back(&p1);
v.push_back(&p2);
v.push_back(&p3);
v.push_back(&p4);
v.push_back(&p5);
// 遍历容器
for (vector::iterator it = v.begin(); it != v.end(); it++) {
cout << "姓名：" << (*it)->m_age << " "
<< "年龄：" << (* (*it)).m_name << endl;
}
}
int main() {
test01();
cout << endl;
test02();
cin.get();
return 0;
}
总结：<>里是什么数据类型，*it解出来的就是什么数据类型。it的本质是个指针
6 Vector容器嵌套容器
学习目标：容器中嵌套容器，我们将所有数据进行遍历输出
vector中嵌套vector。 相当于数组中嵌套数组,也就是个二维数组
注意 vector中嵌套vector的遍历函数写法：
//遍历
for (vector>::iterator it = v.begin(); it != v.end(); it++) {
// 注意小容器的迭代器怎么写
// 因为大容器的vector>::iterator it = v.begin()
// 也就是说 *it=vector。（*it就是一个容器）
// 所以小容器的初始迭代器=(*it).begint()或者it->begint()
// 小容器的结束迭代器=(*it).end()或者it->end()
for (vector::iterator jt = it->begin(); jt!= it->end(); jt++) {
cout << *jt << " ";
}
cout << endl;
}
示例：
#include
using namespace std;
#include
#include
#include
// vector中嵌套vector
// 相当于数组中嵌套数组
void test01() {
vector>v;
// 创建小容器
vectorv1;
vectorv2;
vectorv3;
vectorv4;
// 像小容器中添加数据
for (int i = 1; i < 5; i++) {
v1.push_back(i * 10);
v2.push_back(i * 11);
v3.push_back(i * 12);
v4.push_back(i * 13);
}
//将小容器添加到大容器中
v.push_back(v1);
v.push_back(v2);
v.push_back(v3);
v.push_back(v4);
//遍历
for (vector>::iterator it = v.begin(); it != v.end(); it++) {
for (vector::iterator jt = it->begin(); jt!= it->end(); jt++) {
cout << *jt << " ";
}
cout << endl;
}
}
void test02() {
}
int main() {
test01();
cout << endl;
test02();
cin.get();
return 0;
}
7 vector容量和大小
功能描述：
- 对vector容器的容量和大小操作
函数原型：
-
empty();//判断容器是否为空。如果为空，返回值为1 -
capacity();//容器的容量。capacity的值永远大于等于size的值 -
size();//返回容器中元素的个数 -
resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值0来填充新位置。 //如果容器变短，则末尾超出容器长度的元素被删除。
-
resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。 //如果容器变短，则末尾超出容器长度的元素被删除
#include
using namespace std;
#include
#include
void test01();
// 打印函数
void printVector(vector v1) {
for (vector::iterator it = v1.begin(); it != v1.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test01() {
vectorv0;
for (int i = 0; i < 10; i++) {
v0.push_back(i);
}
// 1.empty函数判断是否为空，为空返回值为1否则返回值为0
if (v0.empty() == 0) {
cout << "此时容器不为空" << endl;
}
if (v0.empty() == 1) {
cout << "此时容器为空" << endl;
}
cout << "容器内的元素如下：" << endl;
printVector(v0); cout << endl;
// 2.查看容量
cout << "此时容器的容量：" << v0.capacity() << endl;
// 3.查看元素个数
cout << "此时容器中元素的个数：" << v0.size() << endl< 
- 判断是否为空 — empty
- 返回元素个数 — size
- 返回容器容量 — capacity
- 重新指定大小 — resize
总结
- vector容器初始化后，编译器会给出容器的容量。容量默认会大于此时元素的个数，容量的具体指由STL算法决定。之后便可以插入数据，使得size（元素的个数）变大；当size==容量时，如果还想插入数据，那么vector容器会动态扩展，保证容量永远大于等于元素个数。
- resize(num,elem);如果resize后的容器长度小于容器容量，那么容器容量不会改变；如果resize后的长度大于容量，那么容量也会增大，容量增大为变大后的长度，也就是说此时容量=元素的个数
比如：此时vector容器中有10个元素，容量为13
resize(5)后，元素个数变为5，容量不变仍为13
resize(12)后，元素个数变为12，容量不变仍为13
resize(13)后，元素个数变为13，容量也不变仍为13
但resize(20)后，元素个数变为20，容量扩大为20。
容器的容量永远大于等于元素个数。
8 vector插入和删除
功能描述：
- 对vector容器进行插入、删除操作
函数原型：
push_back(ele);//尾部插入元素elepop_back();//删除最后一个元素insert(const_iterator pos, ele);//在迭代器指向位置pos前插入元素eleinsert(const_iterator pos, int count,ele);//在迭代器指向位置pos前插入count个元素eleerase(const_iterator pos);//删除迭代器指向的元素。注意不能传入end迭代器，因为它指向容器最后一个元素的下一位erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素。注意这里是左闭右开的原则，也就是他会删除start端点处的数据，但不会删除end端点处的数据！clear();//删除容器中所有元素
#include
using namespace std;
#include
#include
void test01();
// 打印函数
void printVector(vector v1) {
for (vector::iterator it = v1.begin(); it != v1.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test01() {
vectorv0;
// 尾插
v0.push_back(0);
v0.push_back(1);
v0.push_back(2);
v0.push_back(3);
v0.push_back(4);
v0.push_back(5);
v0.push_back(6);
v0.push_back(7);
v0.push_back(8);
//遍历
cout << "vector容器中元素如下：" << endl;
printVector(v0); cout << endl;
// 尾删
v0.pop_back();
cout << "尾删后变成：" << endl;
printVector(v0); cout << endl;
// 指定位置插入1个数据
v0.insert(v0.begin(), 666);
cout << "在v0.begin()前插入一个666" << endl;
printVector(v0); cout << endl;
// 指定位置插入多个数据
v0.insert(v0.begin() +4, 3, 0);
cout << "在v0.begin()+4前插入3个0" << endl;
printVector(v0); cout << endl;
// 删除指定位置数据
v0.erase(v0.begin());
v0.erase(v0.begin()+6);
cout << "同时删除v0.begin()和v0.begin()+7处的数据后:" << endl;
printVector(v0); cout << endl;
// 删除一个区间内的数据
// 如：删除从v0.begin+4到v0.end-1的数据（包括端点）
cout << "删除从v0.begin+4到v0.end()-1的数据" << endl;
v0.erase(v0.begin() + 4, v0.end() -1);
printVector(v0);
cout << "可以看到他会删除v0.begin()+4处的数据，但是不会删除v0.end()-1处的数据，左闭右开" << endl< 
总结：
- 尾插 — push_back
- 尾删 — pop_back
- 插入 — insert (位置迭代器)
- 删除 — erase （位置迭代器）
- 清空 — clear
9 vector数据存取
vector容器有 []、迭代器、at（）三种访问方式
功能描述：
- 对vector中的数据的存取操作
函数原型：
at(int idx);//返回索引idx所指的数据operator[];//返回索引idx所指的数据front();//返回容器中第一个数据元素back();//返回容器中最后一个数据元素
#include
using namespace std;
#include
void test01();
// 打印函数
void printVector(vector v) {
// 1. 利用迭代器访问vector中的元素
cout << "利用迭代器遍历vector容器:" << endl;
for (vector::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl<v1;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
}
printVector(v1);
}
int main() {
test01();
system("pause");
return 0;
}
总结：
- 除了用迭代器获取vector容器中元素，[ ]和at也可以
- front返回容器第一个元素
- back返回容器最后一个元素
10 vector互换容器
巧用容器互换可以收缩内存空间
功能描述：
- 实现两个容器内元素进行互换
函数原型：
swap(vec);// 将vec与本身的元素互换
实际用途：收缩内存
// 巧用swap可以收缩内存
void test02() {
vectorv1;
for (int i = 0; i < 100000; i++) {
v1.push_back(i);
}
cout << "互换容器的实际用途：巧用swap可以收缩内存" << endl;
cout << "给v1容器初始化插入100000个数据后，vi的大小为：" << v1.size() << endl;
cout << "给v1容器初始化插入100000个数据后，vi的容量为：" << v1.capacity() << endl;
v1.resize(100);
cout << endl<<"重新指定v1的大小为100" << endl;
cout << "此时v1的容量为：" << v1.capacity() << endl;
cout << "此时v1的大小为：" << v1.size() << endl;
cout << "容量仍然为" << v1.capacity() << "但我们容器里只有" << v1.size() << "个元素" << endl;
cout << "我们占了这么大的坑，却只放一点东西，太浪费了！！" << endl;
cout << "所以我们可以巧用swap()来减少内存空间的浪费" << endl << endl;
// 注意：不能新建一个容器或者拿别的容器来交换
// 因为我们此时交换容器的目的就是收缩内存，如果新建一个容器或者把此时的容器交换到别的容器中
// 这些容器仍然存放于内存里，相当于没有收缩内存。只是交换一下容量而已。
// 用一个匿名对象来交换容器，可以达到收缩内存的目的
vector(v1).swap(v1);//这一句代码其实分为两段。第一段是用拷贝构造v1的方式来初始化一个匿名对象，第二段是匿名对象与v1互换容器。
// 只能写成一句话。不能写成:vector(v1); vector(v1).swap(v1);这样会导致重定义
// vector(v1)就是匿名对象。它是用v1的容量和大小来初始化一个匿名对象；
//它的特点是当前行执行完后，系统自动回收分配的内存
cout << "匿名对象vector(v1)的容量为：" << vector(v1).capacity() << endl;
cout << "匿名对象vector(v1)的大小为：" << vector(v1).size() << endl;
cout << "v1与匿名对象交换容器后" << endl;
cout << "v1的容量为：" << v1.capacity() << endl;
cout << "v1的大小为：" << v1.size() << endl << endl;
}
巧用swap交换容器，可以收缩内存。
给原来一块很大的内存空间瘦身，必须得与匿名对象互换。
因为匿名对象的特点是，当前行结束后，系统自动回收分配的内存
综合：
#include
using namespace std;
#include
void test01();
// 打印函数
void printVector(vector v) {
for (int i = 0; i < v.size(); i++) {
cout << v.at(i) << " ";
}
cout << endl;
}
// 容器互换
// 1.基本使用
void test01() {
cout << "容器交换前：" << endl;
vectorv1;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
}
cout << "v1:";
printVector(v1);
vectorv2;
for (int i = 10; i < 20; i++) {
v2.push_back(i);
}
cout << endl << "v2:";
printVector(v2);
cout << endl;
cout << "容器交换后：" << endl;
v1.swap(v2);
cout << "v1:";
printVector(v1);
cout << endl << "v2:";
printVector(v2);
}
// 2.实际用途
// 巧用swap可以收缩内存
void test02() {
vectorv1;
for (int i = 0; i < 100000; i++) {
v1.push_back(i);
}
cout << "互换容器的实际用途：巧用swap可以收缩内存" << endl;
cout << "给v1容器初始化插入100000个数据后，vi的大小为：" << v1.size() << endl;
cout << "给v1容器初始化插入100000个数据后，vi的容量为：" << v1.capacity() << endl;
v1.resize(100);
cout << endl<<"重新指定v1的大小为100" << endl;
cout << "此时v1的容量为：" << v1.capacity() << endl;
cout << "此时v1的大小为：" << v1.size() << endl;
cout << "容量仍然为" << v1.capacity() << "但我们容器里只有" << v1.size() << "个元素" << endl;
cout << "我们占了这么大的坑，却只放一点东西，太浪费了！！" << endl;
cout << "所以我们可以巧用swap()来减少内存空间的浪费" << endl << endl;
// 注意：不能新建一个容器或者拿别的容器来交换
// 因为我们此时交换容器的目的就是收缩内存，如果新建一个容器或者把此时的容器交换到别的容器中
// 这些容器仍然存放于内存里，相当于没有收缩内存。只是交换一下容量而已。
// 用一个匿名对象来交换容器，可以达到收缩内存的目的
vector(v1).swap(v1);//这一句代码其实分为两段。第一段是用v1来初始化一个匿名对象，第二段是匿名对象与v1互换容器。
// 只能写成一句话。不能写成:vector(v1); vector(v1).swap(v1);这样会导致重定义
// vector(v1)就是匿名对象。它是用v1的容量和大小来初始化一个匿名对象；
//它的特点是当前行执行完后，系统自动回收分配的内存
cout << "匿名对象vector(v1)的容量为：" << vector(v1).capacity() << endl;
cout << "匿名对象vector(v1)的大小为：" << vector(v1).size() << endl;
cout << "v1与匿名对象交换容器后" << endl;
cout << "v1的容量为：" << v1.capacity() << endl;
cout << "v1的大小为：" << v1.size() << endl << endl;
}
int main() {
test01();
cout << endl << endl;
test02();
system("pause");
return 0;
}
11 vector预留空间
功能描述：
- 减少vector在动态扩展容量时的扩展次数
为什么要减少动态扩展次数，因为动态扩展虽然快，但仍然很麻烦。而且不要随意的去开辟内存空间，操作内存空间还是比较危险的。
函数原型：
reserve(int len);//容器预留len个元素长度，预留位置不能初始化，元素不可访问。
意思就是reserve会在内存里开一块空地（分配内存空间），但空地上的位置都是空位置（内存里没有数据），不能访问，不能初始化。不过我们可以给它赋值，赋完值后就可以访问了。
注意：不能初始化≠不能赋值。初始化和赋值是两种完全不同的操作
-
初始化不是赋值，初始化的含义是在创建对象时赋予一个初值，而赋值是将对象的当前值擦除掉，以一个新值代替。
-
当有对象创建的时候，就是初始化，未创建对象而对象的值被改变就是赋值。
1.我们是已经初始化容器之后才调用的reserve，所以预留位置准不准初始化都无所谓。
2.预留位置只是不准初始化，他是可以赋值的！！
统计vector容器动态扩展次数的方法：
void test01() {
int num=0; // 动态扩展次数
vectorv1;
int* p = NULL; // 不知道指针指向哪里的话，首先让它指向空
// 向vector容器里插入100000个数据，统计vector容器动态扩展次数
for (int i = 0; i < 100000; i++) {
v1.push_back(i);
// 统计动态扩展次数
if (p != &v1[0]) // 判断条件：指针是不是指向容器里元素的首地址
{
p = &v1[0];// 如果指针不是指向容器里第一个元素的首地址，就强制让他指向第一个元素的首地址
num++;// num++，动态扩展一次
}
}
cout << "插入100000个数据不预留空间，vector容器一共动态扩展了：" << num << "次" << endl;
cout << endl;
}
- 首先，指针指向空。我们随后给vector容器里插入数据，然后用指针指向元素首地址，这是第一次开辟内存空间
- 然后随着插入的数据越来越多，当我们第一块内存插满了后，vector容器会动态扩展，动态扩展的机制是：重新找一个更大的内存空间，然后将元数据拷贝新空间，释放原空间，此时数组元素首地址发生改变。而p仍然指向原来的那一块内存空间中的数组元素首地址，p≠此时的&v[0]。
- 因此我们强制让p = &v[0];然后记录动态扩展次数的变量+1
- 依次类推，得到最后的开辟内存数（动态扩展数=开辟内存数-1，第一次开辟内存不算动态扩展）
综合：
#include
using namespace std;
#include
void test01();
// 打印函数
void printVector(vector v) {
for (int i = 0; i < v.size(); i++) {
cout << v.at(i) << " ";
}
cout << endl;
}
// 预留空间
// 作用：减少动态扩展的次数
// 注意：预留空间，无法初始化，无法访问里面的元素
void test01() {
int num=0; // 统计动态扩展次数
vectorv1;
int* p = NULL;
for (int i = 0; i < 100000; i++) {
v1.push_back(i);
// 统计动态扩展次数
if (p != &v1[0]) {
p = &v1[0];
num++;
}
}
cout << "插入100000个数据不预留空间，vector容器一共开辟了：" << num << "次内存" << endl;
cout << endl;
}
// 如果预留了空间，那么动态扩展次数将会下降
void test02() {
int num = 0;
vectorv1;
int* p = NULL;
v1.reserve(100000);
for (int i = 0; i < 100000; i++) {
v1.push_back(i);
// 统计动态扩展次数
if (p != &v1[0]) {
p = &v1[0];
num++;
}
}
cout << "插入100000个数据预留空间，vector容器一共开辟了：" << num << "次内存" << endl;
}
int main() {
test01();
test02();
system("pause");
return 0;
}
总结：如果数据量较大，可以一开始利用reserve预留空间