vector类

vector 的介绍及使用

vector 的介绍

1. vector 是表示可变大小数组的序列容器。
2. 就像数组一样, vector 也采用的连续存储空间来存储元素。也就是意味着可以采用下标对 vector 的元素进行访问,和数组一样高效。但是又不像数组,它的大小是可以动态改变的,而且它的大小会被容器自动处理。
3. 本质讲, vector 使用动态分配数组来存储它的元素。当新元素插入时候,这个数组需要被重新分配大小为了增加存储空间。其做法是,分配一个新的数组,然后将全部元素移到这个数组。就时间而言,这是一个相对代价高的任务,因为每当一个新的元素加入到容器的时候,vector 并不会每次都重新分配大小。
4. vector 分配空间策略: vector 会分配一些额外的空间以适应可能的增长,因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何,重新分配都应该是对数增长的间隔大小,以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
5. 因此, vector 占用了更多的存储空间,为了获得管理存储空间的能力,并且以一种有效的方式动态增长。
6. 与其它动态序列容器相比( deque, list and forward_list ), vector 在访问元素的时候更加高效,在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作,效率更低。比起list forward_list统一的迭代器和引用更好。

vector 的初始化

头文件:<vector>

#include <vector>
using namespace std;  

 构造

// 无参构造:一般用的最多的就是无参:
vector<int> v1;   // 无参构造,创建一个int类型的,空的vector对象
//构造并初始化:用 n 个 value 初始化:
vector<int> v2(10, 3);   // 10个3
// 迭代器区间初始化:begin 👉 end:
vector<int> v3(v2.begin(), v2.end());
//拷贝构造:
vector<int> v4(v2);
//如果我们不要他的头和尾
vector<int> v3(++v2.begin(), --v2.end());

对于迭代器区间初始化,它这里的 InputInerator 不一定是 vector Inerator。它是一个模板,所以你传的是谁的迭代器,它就可以实例化出谁的迭代器,

 去遍历 first 和 last 区间,进行初始化。

所以有些场景我们可以这么初始化:

string s("hello world");
vector<char> v5(s.begin(), s.end());

 调试观察 vector

我们打个断点进入调试,打开监视窗口看看。

#include <iostream>
#include <vector>
#include <string>
using namespace std;
 
void test_vector1() {
	vector<int> v1;
	vector<int> v2(10, 3);
	vector<int> v3(++v2.begin(), --v2.end());
	vector<int> v4(v2);
 
	string s("hello world");
	vector<char> v5(s.begin(), s.end());
}
 
int main(void)
{
	test_vector1();
 
	return 0;
}

具体细节如下:

 string 和 vector 的区别 

刚才通过监视观察,感觉 vector char 已经很像 string 了。

那么:能不能让 vector char 去替代 string 呢? 

答案是否定的。因为 vector char 没有 \0,而 string 结尾是有 \0 的。

vector 是顺序表,存的是任意类型,是针对可动态增长的数组的。

而 string 就只是字符串。

① vector 支持正常的增删查改,但是不支持 += (本身也没必要+=),也不支持比较大小。

② vector 也没有 c_str 这些东西,因为 string 作为字符串专用的类,能提供专有的接口(比如 +=,find),所以这就是 string 存在的意义。

所以并不只是有没有\0的问题

vector 的遍历

 引入

我们先简单介绍 3 种 vector 的遍历方式,然后再介绍一些访问元素的接口。其中为了讲解 "下标 + 方括号" 的遍历方式,我们先提前介绍一下 vector 的 push_back 。除此之外还有反向迭代器、const 迭代器……

 push_back()

 

vector 不能用 operator+= 。string 能用 += ,主要是 string 不仅可以尾插一个字符还可以追加一个字符串。但是 vector 就只支持一个一个数据的插入和删除,push_back 和 pop_back。

我们发现,vector 和 string 一样,是没有提供 push_front 和 pop_front 的,因为挪动数据效率低。

如果你硬是要去头插头删,也没人拦你,你可以用 insert 和 erase 去操作。

所以我们用 push_back 尾插接口去操作!

vector.push_back(内容);

举个例子 :

void vector_Traversal_test() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
}

 下标 + 方括号遍历

 

vector 是连续的空间,又支持 operator[] 和 size() ,所以可以用下标+方括号遍历。

下标 + 方括号:遍历 

void vector_Traversal_test() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
 
	// 遍历
	for (size_t i = 0; i < v.size(); i++) {
		cout << v[i] << " ";
	}
	cout << endl;
}

 运行结果如下:

当然也是可以修改的:

void vector_Traversal_test() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
 
	// 遍历
	for (size_t i = 0; i < v.size(); i++) {
		v[i] += 1;    // 令每个元素+1
		cout << v[i] << " ";
	}
	cout << endl;
}

访问 vector 的 at() 

 

顺便再讲一下 at() ,它和 operator[] 一样,也是用来访问 vector 的,但是 at() 会进行边界检查。

at 用法演示: 

void test_vector4() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
 
	cout << v.at(0) << endl;
	cout << v.at(3) << endl;
}

结果如下:

注意事项:operator[] 会用断言检查越界,而 at() 会抛异常。

用迭代器遍历vector 

 

 

迭代器的读和写: 

void vector_Traversal_test() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
    
    // 用迭代器遍历
	vector<int>::iterator it = v.begin();
	while (it != v.end()) {
		*it -= 1;             // 令每个元素-1
		cout << *it << " ";
		it++;
	}
	cout << endl;
}

 运行结果如下:

范围 for 

vector 支持迭代器,也就支持范围 for,这个我们在模拟实现 string 的时候已经验证过了。

范围 for 的本质就是编译器在编译时自动替换成迭代器,这里也一样。

范围 for 的读和写:

void vector_Traversal_test() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
 
	// 范围for
	for (auto e : v) {
		cout << e << " ";
	}
	cout << endl;
 
	for (auto& e : v) {
		e += 10;
		cout << e << " ";
	}
	cout << endl;
}

 运行结果如下:

 记得范围 for 的写要加引用,这时老生常谈的问题了。

​顺便说一点,原生指针就是天然的迭代器,数组支持范围 for,会被替换成指针:

for (int* p = arr; p < arr + sizeof(arr) / sizeof(int); p++) {}

vector 空间

 获取数据个数的 size() 

和 string 里的一样,是用来获取数据的个数的。 

void test_vector2() {
	vector<int> v(6, 6);        // 生成6个6
	cout << v.size() << endl;
}

 运行结果如下:

 获取 vector 最大存储的 max_size() 

 我们来用 max_size 看看有多大: 

void test_vector3() {
	vector<int> v(6, 6);   // 生成6个6
	cout << v.max_size() << endl;
}

 运行结果如下:

reserve() 

 

reserve: 

void test_vector3() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
 
	v.reserve(100);
}

 调试结果如下:

reserve 会扩容,但是不会影响数据个数。[capacity] 4  → [capacity]100

 resize() 

 " reserve 和 resize 都是开空间的,reserve 只是开空间,而 resize 是一条龙服务,开空间之后还初始化,你还可以指定初始化内容,如果不指定会按默认的类型的缺省值初始化.

resize:

void test_vector4() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
 
	v.resize(100);
}

 

string 的 resize 如果不指定 "填充值" ,默认给的是 \0,而 vector 的 resize 如果不指定,默认给的是其对应类型的缺省值作为 "填充值"。这里是 int 就是 0,如果是指针,对应的缺省值就是空指针。

 我们来试着给 resize 提供指定 "填充值":

void test_vector5() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
 
	v.resize(100, 6);   // 开100个空间,用6补
}

 

注意事项:如果开的数据比之前更小,还会删除数据!

void test_vector4() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
 
	v.resize(2);
}

当然,正如我们 string 章节所说,它的容量并不会因此改变。这里虽然大小变成 2,数据也只有 [0]1 和 [1]2 了,但是容量仍然为 4。

 vector 空间增长问题

① capacity 的代码在 VS 和 g++下分别运行会发现:VS下 capacity 是按 1.5 倍增长的,而 g++ 下 capacity 是按 2 倍增长的。 这个问题经常会考察,不要固化的认为,顺序表增容都是2倍,具体增长多少是根据具体的需求定义的。VS 是 PJ 版本 STL,g++ 是 SGI 版本 STL。

② reserve 只负责开辟空间,如果确定知道需要用多少空间,reserve 可以缓解 vector 增容的代价缺陷问题。

③ resize 在开空间的同时还会进行初始化,影响 size。

 测试

// vector::capacity
#include <iostream>
#include <vector>
 
int main(void)
{
	size_t sz;
	std::vector<int> foo;
	sz = foo.capacity();
	std::cout << "making foo grow:\n";
	for (int i = 0; i < 100; ++i) {
		foo.push_back(i);
		if (sz != foo.capacity()) {
			sz = foo.capacity();
			std::cout << "capacity changed: " << sz << '\n';
		}
	}
}

结果如下:

 g++ 运行结果如下:

making foo grow :
capacity changed : 1
capacity changed : 2
capacity changed : 4
capacity changed : 8
capacity changed : 16
capacity changed : 32
capacity changed : 64
capacity changed : 128

 vector 增删查改

刚才讲 "下标 + 方括号" 的遍历方式的时候已经讲过 push_back 了,

也顺便解释了为什么不提供 push_front 和 pop_front ,所以这里就不多bb了。

 pop_back() 尾删

 

现在我们把 pop_back 简单介绍一下,pop_back 就是尾删,可用来删除 vector 中的数据。

pop_back: 

void test_vector5() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	for (auto e : v) cout << e << " "; cout << endl;
 
	v.pop_back();   // 尾删:3
	for (auto e : v) cout << e << " "; cout << endl;
	
	v.pop_back();   // 尾删:2
	for (auto e : v) cout << e << " "; cout << endl;
}

  运行结果如下:

assign() 赋值 

 

assign 可以把 vector 的内容覆盖掉。允许给一段区间覆盖,也可以给 n 个 value 去覆盖。

用 n 个 value 覆盖: 

void test_vector6() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
 
	v.assign(10, 5);   // 原来是1到4,现在改成10个5
}

 调试结果如下:

为什么 vector 不提供 find 接口

而 vector 之所以不提供 find ,是因为如果去查找元素效率就会是 O(n) ……

可以的,"algorithm库" 里有通用的 find 操作,我们来一睹其芳容 ——

#include <algorithm>

 

该 find 内部是从 begin 到 end 进行一次遍历,其复杂度是 值得一提的是O(n),在C++中,凡是使用迭代器区间,都是左闭右开的 —— (\, first, \, last\, ]   

再去思考 map、set 为什么有 find() 通过迭代器从头到尾遍历 map 与 set 时,得到的结果是按 key 排序的结果,而不是插入时的顺序,所以这两个容器没有 push_back 操作。

其实,插入到 map 与 set 中的元素会被组织到一颗红黑树上,红黑树是一颗平衡二叉树,平衡二叉树是一颗二叉排序树,对一颗二叉排序树的查找有点像二分查找,复杂度是 O(log(n)),由于 map 与 set 的数据结构能有更快的查找方法,所以在容器内提供了 find 方法。

通用查找 find() 

如果非要在 vector 里用 find() ,我们可以用通用 find。

找到了:返回一个迭代器区间那个值的位置;

没找到:返回的是 last ,即右边开区间的位置。

使用方法演示:

void test_vector7() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
 
	vector<int>::iterator ret = find(v.begin(), v.end(), 3);
    // auto ret = find(v.begin(), v.end(), 3);
 
	if (ret != v.end()) {
		cout << "找到了" << endl;
	}
}
 

 insert() 插入

比如我们刚才用通用 find 找到了 3 的位置,我们想在这个位置前面插入一个数据,就可以使用 insert() 插入。

在 3 前面用 insert 插入一个 30: 

void test_vector7() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
 
	vector<int>::iterator ret = find(v.begin(), v.end(), 3);
	if (ret != v.end()) {
		cout << "找到了" << endl;
		v.insert(ret, 30);         // 在ret位置前面插入一个30
	}
 
	for (auto e : v) cout << e << " "; cout << endl;
}

  运行结果如下:

我们刚才说过,虽然没有 vector 没有提供 push_front,但是我们也可以用 insert 去头插。

用 insert 去头插: 

void test_vector8() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
    for (auto e : v) cout << e << " "; cout << endl;
 
	v.insert(v.begin(), -1);   // 在起始位置插入一个-1
 
	for (auto e : v) cout << e << " "; cout << endl;
}

 运行结果如下:

erase() 删除 

 

 我们我们想删除数据,我们就可以用 erase 去删除。

使用 erase 的时要判断一下有没有找到要删除的目标:

void test_vector9() {
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	for (auto e : v) cout << e << " "; cout << endl;
 
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);
	if (pos != v.end()) {   // 判断pos是否存在
		v.erase(pos);       // 删除pos
	}
 
	for (auto e : v) cout << e << " "; cout << endl;
}

 运行结果如下:

如果要删除的目标存在,不会怎么样。

怕的就是要删的目标不存在!比如我要删个 5,但是 vector 里只有 1,2,3,4 。

vector<int>::iterator pos = find(v.begin(), v.end(), 5);
v.erase(pos);

 

如果有了判断,就不会翻车了,如果待删目标不存在,就不会去走 erase()  。 因为 pos 如果找不到就会等于 end() 上的值,我们利用这一点进行 if 判断,

vector<int>::iterator pos = find(v.begin(), v.end(), 5);
if (pos != v.end()) {   // 检查!
	v.erase(pos);   
}

 

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值