Vector容器（黑马程序员）

vector容器，STL中最常用的容器之一

视频与文档链接

1 vector基本概念

功能：

• vector数据结构和数组非常相似，也称为单端数组

普通数组一旦分配内存，容量就被固定了，无法扩展。

vector与普通数组区别：

• 不同之处在于数组是静态空间，而vector可以动态扩展

动态扩展：

• 并不是在原空间之后续接新空间，而是找更大的内存空间(STL中有专门的算法去找这个内存空间），然后将原数据拷贝新空间，释放原空间

1. vector容器前端封闭，一般都是在尾部插入数据：push_back和删除数据：pop_back
2. v.rend()：这个迭代器指向第一个元素的前以为
3. v.begin()：常用的vector迭代器，指向第一个第一个元素
4. v.end():常用的vector迭代器，指向最后一个元素的后一位
5. v.rbegint():这个迭代器指向最后一个元素
6. vector容器的迭代器支持随机访问，可以一下跳好几个元素

2 vector的构造函数

函数原型：

• vector<T> 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<iostream>
using namespace std;
#include<string>
#include<vector>
void test01();
// 打印函数
void printVector(vector<int> v1) {
	for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++) {
		cout << *it << "  ";
	}
	cout << endl;


}


// vector 构造函数

// 1.默认构造（无参构造）
void test01() {
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);

	}
	cout << "默认构造：";
	printVector(v); cout << endl;
	// 2.通过区间方式
	vector<int>v2(v.begin(), v.end() - 2);
	cout << "通过区间的方式构造:";
		printVector(v2); cout << endl;
	// 3.n个元素方式
		vector<int>v3(10, 55);
		cout << "传入n个元素的方式构造:";
		printVector(v3); cout << endl;
	// 4.拷贝构造方式
		vector<int>v4(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<iostream>
using namespace std;
#include<string>
#include<vector>

void test01();
// 打印函数
void printVector(vector<int> v1) {
	for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++) {
		cout << *it << "  ";
	}
	cout << endl;


}

// vector 的赋值操作

void test01() {
	vector<int>v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}cout << "v1：";
	printVector(v1); cout << endl;
	 1.重载等号赋值
	vector<int>v2;
	v2 = v1;
	cout << "v2:";
	printVector(v2); cout << endl;



	// 2.assign函数（区间赋值）
	vector<int>v3;
	v3.assign(v1.begin(), v1.end());
	cout << "v3:";
	printVector(v3);
	cout << endl;



	// 3.assign函数（n个元素赋值)
	vector<int>v4;
	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<int>::iterator
<>里写我们要操作的数据类型

注意STL中每个容器使用前都得包含它的头文件

示例：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
void Myprint(int n) {
	cout << n << endl;
}
void test01() {
// 创建一个vector容器，数组
	vector<int> v;
// 向vector容器中插入数据（尾插）
	v.push_back(10);
	v.push_back(10);
	v.push_back(10);
	v.push_back(10);

// 通过迭代器访问容器里的元素
// 注意迭代器的写法
	vector<int>::iterator itBegin = v.begin();
	vector<int>::iterator itEnd = v.end();
	第一种遍历方式
	//while (itBegin != itEnd) {
	//	cout << *itBegin << endl;
	//	itBegin++;
	//}
	 第二种遍历方式
	//for(vector<int>::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<algorithm>

void Myprint(int n) {
	cout << n << endl;
}

for_each(v.begin(), v.end(), Myprint);

为什么第三个参数用函数名呢？这是利用了回调技术，这个函数一开始不调用，直到for_each遍历的期间才调用这个函数。

底层原理如下：

5 vector存放自定义数据类型

每个容器都有自己专属的迭代器。同一个容器，迭代器的类型与容器的数据类型相匹配

1. vector < Person >::iterator it = v.begin();
   it是指向Person类的指针，*it就是Person类。
   引用Person中的成员：it->m_Age 或者 (*it).m_Age

2. vector<Person*>::iterator it = v.begin();
   it是指向Person *的指针。*it代表的是Person *（Person类型的指针）!！不是Person类
   ( *（*it）)才代表Person类。
   引用Person中的成员：（*it）->m_Age 或者 ( * (*it)).m_Age

3. vector::iterator it = v.begin();
   it 是指向int型的指针，*it代表一个int型数据

总结：<>里是什么数据类型，*it解出来的就是什么数据类型。it的本质是个指针

示例：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>
/*学习目标：容器中嵌套容器，我们将所有数据进行遍历输出

*/
class Person {
public:
	Person(string name, int age) :m_name(name), m_age(age) {}
	string m_name;
	int m_age;
};
void test01(){
	vector<Person>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);
	v.push_back(p1);
	// 遍历容器中的数据
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
		cout <<"姓名："<< it->m_age <<"    " 
			<<"年龄：" << (*it).m_name<<endl;
	
	}
        
}
// 存放自定义数据类型的指针
void test02() {
	vector<Person*>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<Person*>::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<vector<int>>::iterator it = v.begin(); it != v.end(); it++) {
		// 注意小容器的迭代器怎么写
		// 因为大容器的vector<vector<int>>::iterator it = v.begin()
		// 也就是说 *it=vector<int>。（*it就是一个容器）
		// 所以小容器的初始迭代器=(*it).begint()或者it->begint()
		// 小容器的结束迭代器=(*it).end()或者it->end()
		for (vector<int>::iterator jt = it->begin(); jt!= it->end(); jt++) {
			cout << *jt << "    ";
		}
		cout << endl;
	}

示例：

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<string>

// vector中嵌套vector
// 相当于数组中嵌套数组

void test01() {
	vector<vector<int>>v;
	// 创建小容器
	vector<int>v1;
	vector<int>v2;
	vector<int>v3;
	vector<int>v4;
 
	// 像小容器中添加数据
	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<vector<int>>::iterator it = v.begin(); it != v.end(); it++) {
		for (vector<int>::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<iostream>
using namespace std;
#include<string>
#include<vector>
void test01();
// 打印函数
void printVector(vector<int> v1) {
	for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++) {
		cout << *it << "  ";
	}
	cout << endl;


}
void test01() {
	vector<int>v0;
	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<<endl<<endl;


	// 4.重新指定容器的长度，容器变长,用默认值0填充
	v0.resize(20);
	cout << "重新指定容器产长度为20" << endl;
	cout << "重新指定长度后，此时容器的容量为：" << v0.capacity() << endl;
	cout << "容器变长后，它的值如下：" << endl;
	printVector(v0); 
	cout << "此时容器中元素的个数：" << v0.size() << endl;
	cout << endl;

	v0.resize(5);
	cout << "重新指定容器长度为5" << endl;
	cout << "重新指定长度后，此时容器的容量为：" << v0.capacity() << endl;
	cout << "容器变短后，它的值如下：" << endl;
	printVector(v0); 
	cout << "此时容器中元素的个数：" << v0.size() << endl;
	cout << endl;

	// 5.重新指定容器的长度，容器变长，添加自己指定的值(resize重载版本）
	cout << endl;
	v0.resize(35,666);
	cout << "重新指定容器产长度为35，多的值用666来填充" << endl;
	cout << "重新指定长度后，容量为：" << v0.capacity() << endl;
	cout << "容器变长后，它的值如下：" << endl;
	printVector(v0);
	cout << "此时容器中元素的个数：" << v0.size() << endl;
	cout << endl;

	v0.resize(8);
	cout << "重新指定容器长度为8" << endl;
	cout << "重新指定长度后，容量为：" << v0.capacity() << endl;
	cout << "容器变短后，它的值如下：" << endl;
	printVector(v0);
	cout << "此时容器中元素的个数：" << v0.size() << endl;
	cout << endl;
	v0.resize(11);
	
}
int main() {

	test01();
	system("pause");
	return 0;

}

• 判断是否为空 — empty
• 返回元素个数 — size
• 返回容器容量 — capacity
• 重新指定大小 — resize

总结

1. vector容器初始化后，编译器会给出容器的容量。容量默认会大于此时元素的个数，容量的具体指由STL算法决定。之后便可以插入数据，使得size（元素的个数）变大；当size==容量时，如果还想插入数据，那么vector容器会动态扩展，保证容量永远大于等于元素个数。
2. 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); //尾部插入元素ele
• pop_back(); //删除最后一个元素
• insert(const_iterator pos, ele); //在迭代器指向位置pos前插入元素ele
• insert(const_iterator pos, int count,ele);//在迭代器指向位置pos前插入count个元素ele
• erase(const_iterator pos); //删除迭代器指向的元素。注意不能传入end迭代器，因为它指向容器最后一个元素的下一位
• erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素。注意这里是左闭右开的原则，也就是他会删除start端点处的数据，但不会删除end端点处的数据！
• clear(); //删除容器中所有元素

#include<iostream>
using namespace std;
#include<string>
#include<vector>
void test01();
// 打印函数
void printVector(vector<int> v1) {
	for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++) {
		cout << *it << "  ";
	}
	cout << endl;


}

void test01() {
	vector<int>v0;
	// 尾插
	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<<endl<<endl;

	//清空
	v0.clear();
	cout << "清空容器" << endl;
	if (v0.empty() == 0) {
		cout << "此时容器不为空" << endl;
	}
	if (v0.empty() == 1) {
		cout << "此时容器为空" << endl;
	}



}





int main() {
	test01();
	system("pause");
	return 0;


}

总结：

• 尾插 — push_back
• 尾删 — pop_back
• 插入 — insert (位置迭代器)
• 删除 — erase （位置迭代器）
• 清空 — clear

9 vector数据存取

vector容器有 []、迭代器、at（）三种访问方式

功能描述：

• 对vector中的数据的存取操作

函数原型：

• at(int idx); //返回索引idx所指的数据
• operator[]; //返回索引idx所指的数据
• front(); //返回容器中第一个数据元素
• back(); //返回容器中最后一个数据元素

#include<iostream>
using namespace std;
#include<vector>
void test01();
// 打印函数
void printVector(vector<int> v) {
	// 1. 利用迭代器访问vector中的元素
	cout << "利用迭代器遍历vector容器:" << endl;
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << "   ";
	}
	cout << endl<<endl;

	///2.还可以利用中括号方式访问Vector容器中的元素
	cout << "利用中括号方式访问Vector容器中的元素:" << endl;
	for (int i = 0; i < v.size(); i++) {
		cout << v[i] << "   ";
	}
	cout << endl<<endl;
	
	// 3.也可以利用at方式访问
	cout << "利用v.at()的方式访问Vector容器中的元素:" << endl;
	for (int i = 0; i < v.size(); i++) {
		cout << v.at(i) << "   ";

	}
	cout << endl << endl;

	// 3.获取第一个元素
	cout << "v.front()=第一个元素="<<v.front() << endl;

	// 4.获取最后一个元素
	cout << "v.back()=最后一个元素="<<v.back() << endl;


}

void test01() {
	vector<int>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() {
	vector<int>v1;
	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<int>(v1).swap(v1);//这一句代码其实分为两段。第一段是用拷贝构造v1的方式来初始化一个匿名对象，第二段是匿名对象与v1互换容器。
	// 只能写成一句话。不能写成:vector<int>(v1);    vector<int>(v1).swap(v1);这样会导致重定义
	// vector<int>(v1)就是匿名对象。它是用v1的容量和大小来初始化一个匿名对象；
	//它的特点是当前行执行完后，系统自动回收分配的内存
	cout << "匿名对象vector<int>(v1)的容量为：" << vector<int>(v1).capacity() << endl;
	cout << "匿名对象vector<int>(v1)的大小为：" << vector<int>(v1).size() << endl;

	cout << "v1与匿名对象交换容器后" << endl;
	cout << "v1的容量为：" << v1.capacity() << endl;
	cout << "v1的大小为：" << v1.size() << endl << endl;
	

}

巧用swap交换容器，可以收缩内存。
给原来一块很大的内存空间瘦身，必须得与匿名对象互换。
因为匿名对象的特点是，当前行结束后，系统自动回收分配的内存

综合：

#include<iostream>
using namespace std;
#include<vector>
void test01();
// 打印函数
void printVector(vector<int> v) {
	for (int i = 0; i < v.size(); i++) {
		cout << v.at(i) << "  ";
	}
	cout << endl;

}


// 容器互换
// 1.基本使用
void test01() {
	cout << "容器交换前：" << endl;
	vector<int>v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	cout << "v1:";
	printVector(v1);
	vector<int>v2;
	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() {
	vector<int>v1;
	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<int>(v1).swap(v1);//这一句代码其实分为两段。第一段是用v1来初始化一个匿名对象，第二段是匿名对象与v1互换容器。
	// 只能写成一句话。不能写成:vector<int>(v1);    vector<int>(v1).swap(v1);这样会导致重定义
	// vector<int>(v1)就是匿名对象。它是用v1的容量和大小来初始化一个匿名对象；
	//它的特点是当前行执行完后，系统自动回收分配的内存
	cout << "匿名对象vector<int>(v1)的容量为：" << vector<int>(v1).capacity() << endl;
	cout << "匿名对象vector<int>(v1)的大小为：" << vector<int>(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. 初始化不是赋值，初始化的含义是在创建对象时赋予一个初值，而赋值是将对象的当前值擦除掉，以一个新值代替。

2. 当有对象创建的时候，就是初始化，未创建对象而对象的值被改变就是赋值。

1.我们是已经初始化容器之后才调用的reserve，所以预留位置准不准初始化都无所谓。
2.预留位置只是不准初始化，他是可以赋值的！！

统计vector容器动态扩展次数的方法：

void test01() {
	int num=0;	// 动态扩展次数
	vector<int>v1;
	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;
}

1. 首先，指针指向空。我们随后给vector容器里插入数据，然后用指针指向元素首地址，这是第一次开辟内存空间
2. 然后随着插入的数据越来越多，当我们第一块内存插满了后，vector容器会动态扩展，动态扩展的机制是：重新找一个更大的内存空间，然后将元数据拷贝新空间，释放原空间，此时数组元素首地址发生改变。而p仍然指向原来的那一块内存空间中的数组元素首地址，p≠此时的&v[0]。
3. 因此我们强制让p = &v[0];然后记录动态扩展次数的变量+1
4. 依次类推，得到最后的开辟内存数（动态扩展数=开辟内存数-1，第一次开辟内存不算动态扩展）

综合：

#include<iostream>
using namespace std;
#include<vector>
void test01();
// 打印函数
void printVector(vector<int> v) {
	for (int i = 0; i < v.size(); i++) {
		cout << v.at(i) << "  ";
	}
	cout << endl;

}





// 预留空间
// 作用：减少动态扩展的次数
// 注意：预留空间，无法初始化，无法访问里面的元素
void test01() {
	int num=0;	// 统计动态扩展次数
	vector<int>v1;
	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;
	vector<int>v1;
	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预留空间文章来源地址https://www.toymoban.com/news/detail-720008.html

到了这里，关于Vector容器（黑马程序员）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！