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容器(黑马程序员)_第1张图片



  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 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;
}

Vector容器(黑马程序员)_第2张图片






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容器(黑马程序员)_第3张图片

总结: vector赋值方式比较简单,使用operator=,或者assign都可以






4 vector存放内置数据类型

容器: vector

算法: for_each

迭代器: vector::iterator
<>里写我们要操作的数据类型

注意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;
}



Vector容器(黑马程序员)_第4张图片



STL自带的遍历算法: for_each

// 首先包含算法头文件
#include

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

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

Vector容器(黑马程序员)_第5张图片
为什么第三个参数用函数名呢?这是利用了回调技术,这个函数一开始不调用,直到for_each遍历的期间才调用这个函数。

底层原理如下:
Vector容器(黑马程序员)_第6张图片







5 vector存放自定义数据类型

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

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


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


  1. 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;
}




Vector容器(黑马程序员)_第7张图片

总结:<>里是什么数据类型,*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;
}

Vector容器(黑马程序员)_第8张图片









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<

Vector容器(黑马程序员)_第9张图片

  • 判断是否为空 — 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
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<

Vector容器(黑马程序员)_第10张图片
总结:

  • 尾插 — 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容器(黑马程序员)_第11张图片
总结:

  • 除了用迭代器获取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;


}

Vector容器(黑马程序员)_第12张图片






11 vector预留空间

功能描述:

  • 减少vector在动态扩展容量时的扩展次数

为什么要减少动态扩展次数,因为动态扩展虽然快,但仍然很麻烦。而且不要随意的去开辟内存空间,操作内存空间还是比较危险的。



函数原型:

  • reserve(int len);//容器预留len个元素长度,预留位置不能初始化,元素不可访问。
    意思就是reserve会在内存里开一块空地(分配内存空间),但空地上的位置都是空位置(内存里没有数据),不能访问,不能初始化。不过我们可以给它赋值,赋完值后就可以访问了。

注意:不能初始化≠不能赋值。初始化和赋值是两种完全不同的操作

  1. 初始化不是赋值,初始化的含义是在创建对象时赋予一个初值,而赋值是将对象的当前值擦除掉,以一个新值代替。

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



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


}

Vector容器(黑马程序员)_第13张图片

总结:如果数据量较大,可以一开始利用reserve预留空间

你可能感兴趣的:(C++,算法,数据结构,c++)