////// 欢迎来到 aramae 的博客,愿 Bug 远离,好运常伴! //////
博主的Gitee地址: 阿拉美 (aramae) - Gitee.com
时代不会辜负长期主义者,愿每一个努力的人都能达到理想的彼岸。
- 1.vector的介绍及使用
- 2.vector深度剖析及模拟实现
引言:本章开始学习STL的 vector 容器,学习包括使用和对vector的深入理解加模拟实现。
1.vector的介绍及使用
1.1 vector的介绍

-
- vector是表示可变大小数组的序列容器。
-
- 就像数组一样,vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素 进行访问,和数组一样高效。但是又不像数组,它的大小是可以动态改变的,而且它的大小会被容器自动处理。
-
- 本质讲,vector使用动态分配数组来存储它的元素。当新元素插入时候,这个数组需要被重新分配大小 为了增加存储空间。其做法是,分配一个新的数组,然后将全部元素移到这个数组。就时间而言,这是 一个相对代价高的任务,因为每当一个新的元素加入到容器的时候,vector并不会每次都重新分配大 小。
-
- vector分配空间策略:vector会分配一些额外的空间以适应可能的增长,因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何,重新分配都应该是 对数增长的间隔大小,以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
-
- 因此,vector占用了更多的存储空间,为了获得管理存储空间的能力,并且以一种有效的方式动态增 长。
-
- 与其它动态序列容器相比(deque, list and forward_list), vector在访问元素的时候更加高效,在末 尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作,效率更低。比起listforward_list 统一的迭代器和引用更好。
使用STL的三个境界:能用,明理,能扩展 ,那么下面学习vector,我们也是按照这个方法去学习
cplusplus.com/reference/vector/vector/https://cplusplus.com/reference/vector/vector/
1.2 vector的使用
vector学习时一定要学会查看文档:vector的文档介绍,vector在实际中非常的重要,在实际中我们熟悉常见的接口就可以,下面列出了哪些接口是要重点掌握的。
1.2.1 vector的定义
std::vector
是标准库提供的一个动态数组容器 ,位于 <vector>
头文件中。它被设计为可以存储同一类型的多个元素 ,并能自动管理内存,支持动态调整大小。

构造函数:

cpp
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers; // 创建一个空的vector,用于存储int类型元素
numbers.push_back(10);
numbers.push_back(20);
for (int num : numbers) {
std::cout << num << " ";
}
return 0;
}
cpp
#include <iostream>
#include <vector>
int main() {
std::vector<int> scores(5, 80); // 创建包含5个元素的vector,每个元素初始值为80
for (int score : scores) {
std::cout << score << " ";
}
return 0;
}
cpp
#include <iostream>
#include <vector>
int main() {
std::vector<int> original = {1, 2, 3};
std::vector<int> copyVec(original); // 通过拷贝构造,创建与original内容相同的vector
for (int num : copyVec) {
std::cout << num << " ";
}
return 0;
}
cpp
#include <iostream>
#include <vector>
#include <array>
int main() {
std::array<int, 4> arr = {10, 20, 30, 40};
std::vector<int> newVec(arr.begin(), arr.end()); // 使用数组的迭代器范围初始化vector
for (int num : newVec) {
std::cout << num << " ";
}
return 0;
}
1.2.2 vector iterator 的使用



1. 正向迭代器基础使用
iterator
用于遍历和修改 vector
中的元素,const_iterator
则用于只读遍历。
cpp
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
// 使用iterator遍历并修改元素
for (std::vector<int>::iterator it = numbers.begin(); it != numbers.end(); ++it) {
*it = *it * 2; // 将每个元素翻倍
}
// 使用const_iterator只读遍历元素
for (std::vector<int>::const_iterator cit = numbers.begin(); cit != numbers.end(); ++cit) {
std::cout << *cit << " ";
}
std::cout << std::endl;
return 0;
}
2. 基于范围的 for 循环与迭代器
C++11 引入的基于范围的 for
循环,本质上也是借助迭代器实现的,使用起来更加简洁。
cpp
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
// 基于范围的for循环,修改元素
for (auto& num : numbers) {
num = num * 3;
}
// 基于范围的for循环,只读遍历元素
for (const auto& num : numbers) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
3. 迭代器用于插入和删除元素
cpp
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 4, 5};
// 在指定位置插入元素
auto insertIt = numbers.begin() + 2; // 定位到要插入的位置
numbers.insert(insertIt, 3); // 在该位置插入元素3
// 删除指定位置的元素
auto eraseIt = numbers.begin() + 3; // 定位到要删除的位置
numbers.erase(eraseIt); // 删除该位置的元素
for (int num : numbers) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
4. 反向迭代器
std::vector
还提供了反向迭代器(reverse_iterator
和 const_reverse_iterator
),用于从后往前遍历 vector
。
cpp
#include <iostream>
#include <vector>
int main() {
std::vector<int> numbers = {1, 2, 3, 4, 5};
// 使用reverse_iterator反向遍历元素
for (std::vector<int>::reverse_iterator rit = numbers.rbegin(); rit != numbers.rend(); ++rit) {
std::cout << *rit << " ";
}
std::cout << std::endl;
return 0;
}
注意事项
- 迭代器失效 :当对
vector
进行插入、删除等修改操作时,可能会导致迭代器失效。例如,插入元素可能引发内存重新分配,原来的迭代器就不再有效。所以在使用迭代器进行操作时,要特别注意操作后的迭代器状态。
1.2.3 vector 空间增长问题


- capacity的代码在vs和g++下分别运行会发现,vs 下 capacity 是按 1.5 倍增长的, g++ 是按 2 倍增长的。
- 这个问题经常会考察,不要固化的认为,vector增容都是2倍,具体增长多少是根据具体的需求定义的。
- vs是PJ版本STL,g++是SGI版本STL。
- reserve只负责开辟空间,如果确定知道需要用多少空间,reserve可以缓解vector增容的代价缺陷问题。
- resize在开空间的同时还会进行初始化,影响size。
cpp
// 测试vector的默认扩容机制
voidTestVectorExpand()
{
size_tsz;
vector<int>v;
sz=v.capacity();
cout<<"making v grow:\n";
for (inti=0; i<100; ++i)
{
v.push_back(i);
if (sz!=v.capacity())
{
sz=v.capacity();
cout<<"capacity changed: "<<sz<<'\n';
}
}
}
vs:运行结果:vs下使用的STL基本是按照1.5倍方式扩容makingfoogrow:
capacitychanged: 1
capacitychanged: 2
capacitychanged: 3
capacitychanged: 4
capacitychanged: 6
capacitychanged: 9
capacitychanged: 13
capacitychanged: 19
capacitychanged: 28
capacitychanged: 42
capacitychanged: 63
capacitychanged: 94
capacitychanged: 141
g++运行结果:linux下使用的STL基本是按照2倍方式扩容makingfoogrow:
capacitychanged: 1
capacitychanged: 2
capacitychanged: 4
capacitychanged: 8
capacitychanged: 16
capacitychanged: 32
capacitychanged: 64
capacitychanged: 128
// 如果已经确定vector中要存储元素大概个数,可以提前将空间设置足够// 就可以避免边插入边扩容导致效率低下的问题了
voidTestVectorExpandOP()
{
vector<int>v;
size_tsz=v.capacity();
v.reserve(100); // 提前将容量设置好,可以避免一遍插入一遍扩容
cout<<"making bar grow:\n";
for (inti=0; i<100; ++i)
{
v.push_back(i);
if (sz!=v.capacity())
{
sz=v.capacity();
cout<<"capacity changed: "<<sz<<'\n';
}
}
}
1.补充:reserve和resize 的区别:
在 C++ 中,
std::vector
的reserve
和resize
是两个用于管理容器内存和大小的重要方法,但它们的功能和用途有本质区别:核心区别
操作 功能 是否改变元素数量( size()
)是否改变容量( capacity()
)元素初始化 reserve(n)
预先分配至少能容纳 n
个元素的内存空间,但不创建新元素。❌ 不改变 ✅ 可能增加(若 n > capacity()
)❌ 不初始化元素 resize(n)
调整容器的元素数量为 n
: - 若n > size()
,新增元素并初始化; - 若n < size()
,删除多余元素。✅ 强制变为 n
✅ 可能增加(若 n > capacity()
)✅ 新增元素会被初始化为默认值或指定值 示例对比
1.
reserve
的作用
cpp#include <vector> #include <iostream> int main() { std::vector<int> vec; std::cout << "初始状态: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl; vec.reserve(100); // 预分配内存,但不创建元素 std::cout << "reserve(100) 后: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl; // 直接访问元素会导致越界错误! // vec[0] = 1; // 错误:size 仍为0,无有效元素 vec.push_back(1); // 正常添加元素 std::cout << "push_back(1) 后: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl; }
plaintext
cpp初始状态: size=0, capacity=0 reserve(100) 后: size=0, capacity=100 push_back(1) 后: size=1, capacity=100
reserve(100)
仅增加容量到 100,但size
仍为 0,容器中没有元素。- 若直接通过下标访问元素(如
vec[0]
)会导致越界错误,因为元素尚未创建。2.
resize
的作用
cpp#include <vector> #include <iostream> int main() { std::vector<int> vec; std::cout << "初始状态: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl; vec.resize(5); // 调整大小为5,新增元素默认初始化为0 std::cout << "resize(5) 后: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl; // 元素已被创建并初始化为0 for (int i = 0; i < vec.size(); ++i) { std::cout << "vec[" << i << "]=" << vec[i] << " "; } std::cout << std::endl; vec.resize(3); // 缩小大小,删除多余元素 std::cout << "resize(3) 后: size=" << vec.size() << ", capacity=" << vec.capacity() << std::endl; }
plaintext
cpp初始状态: size=0, capacity=0 resize(5) 后: size=5, capacity=5 vec[0]=0 vec[1]=0 vec[2]=0 vec[3]=0 vec[4]=0 resize(3) 后: size=3, capacity=5
resize(5)
不仅增加容量到 5,还创建了 5 个元素并初始化为 0。resize(3)
减少元素数量为 3,但容量保持不变(因为没有必要释放内存)。3. 指定初始值的
resize
cpp#include <vector> #include <iostream> int main() { std::vector<int> vec = {1, 2, 3}; vec.resize(5, 100); // 新增2个元素,初始值为100 for (int num : vec) { std::cout << num << " "; // 输出: 1 2 3 100 100 } }
何时使用
reserve
或resize
?
使用
reserve
:当你预先知道需要存储的元素数量时,可通过reserve
避免多次扩容带来的性能开销。例如:
cppstd::vector<int> data; data.reserve(1000); // 预分配足够空间,后续push_back不会触发扩容 for (int i = 0; i < 1000; ++i) { data.push_back(i); }
使用
resize
:当你需要直接调整容器的元素数量,并且希望新增元素被初始化时。
cppstd::vector<int> matrix(10); // 创建10个元素的vector,初始值为0 matrix.resize(20, 1); // 扩展到20个元素,新增元素初始值为1
关键注意事项
reserve
不会初始化元素:预分配的内存中没有有效元素,直接访问会导致未定义行为。resize
可能导致迭代器失效:若触发内存重新分配,所有迭代器都会失效。capacity
总是大于等于size
:容器的容量永远不会小于当前元素数量。
2.容量接口使用代码示例:
cpp
#include <iostream>
#include <vector>
using namespace std;
int main() {
// 1. 初始化 vector
vector<int> vec = {1, 2, 3};
// 2. size:获取数据个数
cout << "size: " << vec.size() << endl;
// 3. capacity:获取容量大小
cout << "capacity: " << vec.capacity() << endl;
// 4. empty:判断是否为空
if (vec.empty()) {
cout << "vector is empty" << endl;
} else {
cout << "vector is not empty" << endl;
}
// 5. resize:改变 vector 的 size
// 扩展 size 到 5,新增元素默认值为 0
vec.resize(5);
cout << "after resize(5): " << endl;
cout << "size: " << vec.size() << ", elements: ";
for (int num : vec) {
cout << num << " ";
}
cout << endl;
// 缩小 size 到 2,删除多余元素
vec.resize(2);
cout << "after resize(2): " << endl;
cout << "size: " << vec.size() << ", elements: ";
for (int num : vec) {
cout << num << " ";
}
cout << endl;
// 6. reserve:改变 vector 的 capacity
// 预分配容量到 10
vec.reserve(10);
cout << "after reserve(10): " << endl;
cout << "capacity: " << vec.capacity() << endl;
return 0;
}
1.2.4 vector 增删查改


增删查改接口使用代码示例:
cpp
#include <iostream>
#include <vector>
#include <algorithm> // 引入find算法所需头文件
int main() {
// 初始化一个vector
std::vector<int> numbers;
// 1. push_back:尾插
numbers.push_back(10);
numbers.push_back(20);
numbers.push_back(30);
std::cout << "After push_back, vector: ";
for (int num : numbers) {
std::cout << num << " ";
}
std::cout << std::endl;
// 2. pop_back:尾删
numbers.pop_back();
std::cout << "After pop_back, vector: ";
for (int num : numbers) {
std::cout << num << " ";
}
std::cout << std::endl;
// 3. find:查找
auto it = std::find(numbers.begin(), numbers.end(), 20);
if (it != numbers.end()) {
std::cout << "Element 20 found in the vector." << std::endl;
} else {
std::cout << "Element 20 not found in the vector." << std::endl;
}
// 4. insert:在指定位置之前插入
auto insertIt = numbers.begin() + 1; // 插入位置在第二个元素之前
numbers.insert(insertIt, 15);
std::cout << "After insert, vector: ";
for (int num : numbers) {
std::cout << num << " ";
}
std::cout << std::endl;
// 5. erase:删除指定位置的数据
auto eraseIt = numbers.begin() + 1; // 删除第二个元素
numbers.erase(eraseIt);
std::cout << "After erase, vector: ";
for (int num : numbers) {
std::cout << num << " ";
}
std::cout << std::endl;
// 6. swap:交换两个vector的数据空间
std::vector<int> anotherNumbers = {40, 50};
numbers.swap(anotherNumbers);
std::cout << "After swap, numbers vector: ";
for (int num : numbers) {
std::cout << num << " ";
}
std::cout << std::endl;
std::cout << "After swap, anotherNumbers vector: ";
for (int num : anotherNumbers) {
std::cout << num << " ";
}
std::cout << std::endl;
// 7. operator[]:像数组一样访问
if (!anotherNumbers.empty()) {
std::cout << "Accessing element using operator[], value: " << anotherNumbers[0] << std::endl;
}
return 0;
}
1.2.5 vector 迭代器失效问题。(重点)
迭代器的主要作用就是让算法能够不用关心底层数据结构,其底层实际就是一个指针,或者是对指针进行了封装,比如:vector的迭代器就是原生态指针T* 。因此迭代器失效,实际就是迭代器底层对应指针所指向的空间被销毁了,而使用一块已经被释放的空间,造成的后果是程序崩溃(即如果继续使用已经失效的迭代器,程序可能会崩溃)。
**对于vector可能会导致其迭代器失效的操作有:**会引起其底层空间改变的操作,都有可能是迭代器失效,比如:resize、reserve、insert、assign、push_back等。
1.插入操作导致迭代器失效
- 扩容时迭代器失效 :当
vector
调用push_back
、insert
等插入函数,且当前vector
容量已满,需要重新分配内存(一般扩容为原来容量的 2 倍,不同编译器实现可能有差异 )时,所有迭代器都会失效。因为重新分配内存后,vector
中元素的存储位置发生了变化。
cpp
#include <vector>
int main() {
std::vector<int> vec = {1, 2, 3};
auto it = vec.begin(); // 定义迭代器
vec.push_back(4); // 假设此时触发扩容
// 此时it失效,不能再使用it进行操作,如 *it 是未定义行为
return 0;
}
- 插入元素但未扩容时迭代器失效 :当使用
insert
在vector
中间插入元素且未触发扩容时,从插入位置开始之后的迭代器都会失效,因为插入元素后,插入位置之后的元素位置都发生了移动。
cpp
#include <vector>
int main() {
std::vector<int> vec = {1, 2, 3};
auto it = vec.begin() + 1; // 指向元素2
vec.insert(it, 4); // 插入元素4,未触发扩容
// 此时it以及it之后的迭代器都失效
return 0;
}
2.删除操作导致迭代器失效
erase
删除元素导致迭代器失效 :当调用erase
删除元素时,指向被删除元素以及其后的迭代器都会失效
cpp
#include <vector>
int main() {
std::vector<int> vec = {1, 2, 3};
auto it = vec.begin() + 1; // 指向元素2
vec.erase(it); // 删除元素2
// 此时it以及it之后的迭代器都失效,不能再使用
return 0;
}
clear
清空vector
导致迭代器失效 :clear
函数会删除vector
中的所有元素,所有迭代器都会失效
cpp
#include <vector>
int main() {
std::vector<int> vec = {1, 2, 3};
auto it = vec.begin();
vec.clear(); // 清空vector
// 此时it失效,不能再对it进行操作
return 0;
}
3.其他操作导致迭代器失效
- resize改变大小导致迭代器失效:如果resize后的大小小于当前大小,会删除后面多余的元素,指向被删除元素以及其后的迭代器都会失效;如果resize后的大小大于当前大小且触发了内存重新分配,所有迭代器都会失效。
cpp
#include <vector>
int main() {
std::vector<int> vec = {1, 2, 3};
auto it = vec.begin() + 1;
vec.resize(1); // 缩小vector大小
// 此时it失效
return 0;
}
汇总:
cpp
#include <iostream>
using namespace std;
#include <vector>
int main()
{
vector<int> v{1,2,3,4,5,6};
auto it = v.begin();
// 将有效元素个数增加到100个,多出的位置使用8填充,操作期间底层会扩容
// v.resize(100, 8);
// reserve的作用就是改变扩容大小但不改变有效元素个数,操作期间可能会引起底层容量改变
// v.reserve(100);
// 插入元素期间,可能会引起扩容,而导致原空间被释放
// v.insert(v.begin(), 0);
// v.push_back(8);
// 给vector重新赋值,可能会引起底层容量改变
v.assign(100, 8);
/*
出错原因:以上操作,都有可能会导致vector扩容,也就是说vector底层原理旧空间被释放掉,
而在打印时,it还使用的是释放之间的旧空间,在对it迭代器操作时,实际操作的是一块已经被释放的
空间,而引起代码运行时崩溃。
解决方式:在以上操作完成之后,如果想要继续通过迭代器操作vector中的元素,只需给it重新
赋值即可。
*/
while(it != v.end())
{
cout<< *it << " " ;
++it;
}
cout<<endl;
int a[] = { 1, 2, 3, 4 };
vector<int> v(a, a + sizeof(a) / sizeof(int));
// 使用find查找3所在位置的iterator
vector<int>::iterator pos = find(v.begin(), v.end(), 3);
// 删除pos位置的数据,导致pos迭代器失效。
v.erase(pos);
cout << *pos << endl; // 此处会导致非法访问
return 0;
}
注意:Linux下,g++编译器对迭代器失效的检测并不是非常严格,处理也没有vs下极端。
cpp
// 1. 扩容之后,迭代器已经失效了,程序虽然可以运行,但是运行结果已经不对了
int main()
{
vector<int> v{1,2,3,4,5};
for(size_t i = 0; i < v.size(); ++i)
cout << v[i] << " ";
cout << endl;
auto it = v.begin();
cout << "扩容之前,vector的容量为: " << v.capacity() << endl;
// 通过reserve将底层空间设置为100,目的是为了让vector的迭代器失效
v.reserve(100);
cout << "扩容之后,vector的容量为: " << v.capacity() << endl;
// 经过上述reserve之后,it迭代器肯定会失效,在vs下程序就直接崩溃了,但是linux下不会
// 虽然可能运行,但是输出的结果是不对的
while(it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}
程序输出:
1 2 3 4 5
扩容之前,vector的容量为: 5
扩容之后,vector的容量为: 100
0 2 3 4 5 409 1 2 3 4 5
// 2. erase删除任意位置代码后,linux下迭代器并没有失效
// 因为空间还是原来的空间,后序元素往前搬移了,it的位置还是有效的
#include <vector>
#include <algorithm>
int main()
{
vector<int> v{1,2,3,4,5};
vector<int>::iterator it = find(v.begin(), v.end(), 3);
v.erase(it);
cout << *it << endl;
while(it != v.end())
{
cout << *it << " ";
++it;
}
cout << endl;
return 0;
}
程序可以正常运行,并打印:
4
4 5
// 3: erase删除的迭代器如果是最后一个元素,删除之后it已经超过end
// 此时迭代器是无效的,++it导致程序崩溃
int main()
{
vector<int> v{1,2,3,4,5};
// vector<int> v{1,2,3,4,5,6};
auto it = v.begin();
while(it != v.end())
{
if(*it % 2 == 0)
v.erase(it);
++it;
}
for(auto e : v)
cout << e << " ";
cout << endl;
return 0;
}
========================================================
// 使用第一组数据时,程序可以运行
[sly@VM-0-3-centos 20220114]$ g++ testVector.cpp -std=c++11
[sly@VM-0-3-centos 20220114]$ ./a.out
1 3 5
=========================================================
// 使用第二组数据时,程序最终会崩溃
[sly@VM-0-3-centos 20220114]$ vim testVector.cpp
[sly@VM-0-3-centos 20220114]$ g++ testVector.cpp -std=c++11
[sly@VM-0-3-centos 20220114]$ ./a.out
Segmentation fault
从上述三个例子中可以看到:SGI STL中,迭代器失效后,代码并不一定会崩溃,但是运行结果肯定不对,如果it不在begin和end范围内,肯定会崩溃的。
与vector类似,string在插入+扩容操作+erase之后,迭代器也会失效
cpp
#include <string>
void TestString(){
迭代器失效解决办法:在使用前,对迭代器重新赋值即可。
{
string s("hello");
auto it = s.begin();
// 放开之后代码会崩溃,因为resize到20会string会进行扩容
// 扩容之后,it指向之前旧空间已经被释放了,该迭代器就失效了
// 后序打印时,再访问it指向的空间程序就会崩溃
//s.resize(20, '!');
while (it != s.end())
{
cout << *it;
++it;
}
cout << endl;
it = s.begin();
while (it != s.end())
{
it = s.erase(it);
// 按照下面方式写,运行时程序会崩溃,因为erase(it)之后
// it位置的迭代器就失效了
// s.erase(it);
++it;
}
迭代器失效解决办法:在使用前,对迭代器重新赋值即可。
2.vector深度剖析及模拟实现

2.1 std::vector的核心框架接口的模拟实现 aramae::vector
cpp
#pragma once
#include<assert.h>
#include<iostream>
using namespace std;
namespace aramae
{
template <class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator begin() const
{
return _start;
}
const_iterator end() const
{
return _finish;
}
// vector<int> v(10, 1);
// vector<int> v(10u, 1);
// vector<string> v1(10, "1111");
//构造函数
vector(size_t n, const T& val = T())
{
resize(n, val);
}
vector(int n, const T& val = T())
{
resize(n, val);
}
// 基于输入迭代器范围的向量构造函数
template <class InputIterator>
vector(InputIterator first, InputIterator last)
{
while (first != last)
{
push_back(*first);
++first;
}
}
vector() {}
// 拷贝构造函数
//1.
vector(const vector<T>& v)
{
_start = new T[v.capacity()];
//memcpy(_start, v._start, sizeof(T)*v.size());
for (size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
}
//2.
//vector(const vector<T>& v)
// :_start(nullptr)
// , _finish(nullptr)
// , _endofstorage(nullptr)
//{
// reserve(v.capacity);
// for (auto e : v)
// {
// push_back(e);
// }
//}
void swap(vector<T>& v)
{
std::swap(_start, v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
// v1 = v2
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
~vector()
{
if (_start)
{
delete[] _start;
_start = _finish = _endofstorage = nullptr;
}
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size();
T* tmp = new T[n];
if (_start)
{
//memcpy(tmp, _start, sizeof(T) * sz);
for (size_t i = 0; i < sz; i++)
{
tmp[i] = _start[i];
}
delete[] _start;
}
_start = tmp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}
void resize(size_t n, const T& val = T())
{
if (n < size())
{
_finish = _start + n;
}
else
{
reserve(n);
while (_finish != _start + n)
{
*_finish = val;
++_finish;
}
}
}
void push_back(const T& x)
{
/*if (_finish == _endofstorage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_finish = x;
++_finish;*/
insert(end(), x);
}
void pop_back()
{
erase(--end());
}
size_t capacity() const
{
return _endofstorage - _start;
}
size_t size() const
{
return _finish - _start;
}
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos) const
{
assert(pos < size());
return _start[pos];
}
iterator insert(iterator pos, const T& x)
{
assert(pos > _start && pos < _finish);
if (_endofstorage == _finish)
{
size_t len = pos - _start;
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
// 解决pos迭代器失效问题
pos = len + _start;
}
iterator end = _finish-1;
while (end > pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
++_finish;
return pos;
}
iterator erase(iterator pos)
{
assert(pos >= _start && pos < _finish);
iterator it = pos + 1;
while (it != _finish)
{
*(it - 1) = *it;
++it;
}
--_finish;
return pos;
}
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _endofstorage = nullptr;
};
void print(const vector<int>& v)
{
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
}
}
cpp
#include"vector.h"
using namespace aramae;
using namespace std;
void test_vector1()
{
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
for (size_t i = 0; i < v1.size(); i++)
{
v1[i]++;
}
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
print(v1);
}
void test_vector2()
{
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
v1.push_back(5);
v1.push_back(5);
v1.push_back(5);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
v1.insert(v1.begin(), 100);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
/*vector<int>::iterator p = v1.begin() + 3;
v1.insert(p, 300);*/
vector<int>::iterator p = v1.begin() + 3;
//v1.insert(p+3, 300);
// insert以后迭代器可能会失效(扩容)
// 记住,insert以后就不要使用这个形参迭代器了,因为他可能失效了
v1.insert(p, 300);
// 高危行为
// *p += 10;
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
}
void test_vector3()
{
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
v1.push_back(6);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
auto it = v1.begin();
while (it != v1.end())
{
if (*it % 2 == 0)
{
it = v1.erase(it);
}
else
{
++it;
}
}
//v1.erase(v1.begin());
//auto it = v1.begin()+4;
//v1.erase(it);
//// erase以后,迭代器失效了,不能访问
//// vs进行强制检查,访问会直接报错
//cout << *it << endl;
//++it;
//cout << *it << endl;
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
}
void test_vector4()
{
vector<int> v;
v.resize(10, 0);
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
int i = 0;
int j = int();
int k = int(1);
}
void test_vector5()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);
vector<int> v1(v);
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
vector<int> v2;
v2.resize(10, 1);
v1 = v2;
for (auto e : v1)
{
cout << e << " ";
}
cout << endl;
}
void test_vector6()
{
vector<string> v;
v.push_back("111111111111111111");
v.push_back("222222222222222222");
v.push_back("333333333333333333");
v.push_back("444444444444444444");
v.push_back("555555555555555555");
for (auto& e : v)
{
cout << e << " ";
}
cout << endl;
vector<string> v1(v);
for (auto& e : v1)
{
cout << e << " ";
}
cout << endl;
}
void test_vector7()
{
vector<int> v(10, 1);
vector<string> v1(10, "1111");
vector<int> v2(10, 1);
// vector<int> v;
for (auto e : v)
{
cout << e << " ";
}
cout << endl;
vector<int> v3(v.begin(), v.end());
for (auto e : v3)
{
cout << e << " ";
}
cout << endl;
string str("hello world");
vector<char> v4(str.begin(), str.end());
for (auto e : v4)
{
cout << e << " ";
}
cout << endl;
int a[] = { 16,2,77,29 };
vector<int> v5(a, a + 4);
for (auto e : v5)
{
cout << e << " ";
}
cout << endl;
}
int main()
{
test_vector7();
return 0;
}
2.2 使用memcpy拷贝问题
假设模拟实现的vector中的reserve接口中,使用memcpy进行的拷贝,以下代码会发生什么问题?
cpp
int main()
{
bite::vector<bite::string> v;
v.push_back("1111");
v.push_back("2222");
v.push_back("3333");
return 0;
}
问题分析:
-
- memcpy是内存的二进制格式拷贝,将一段内存空间中内容原封不动的拷贝到另外一段内存空间中
-
- 如果拷贝的是内置类型的元素,memcpy既高效又不会出错,但如果拷贝的是自定义类型元素,并且自 定义类型元素中涉及到资源管理时,就会出错,因为memcpy的拷贝实际是浅拷贝。

结论:如果对象中涉及到资源管理时,千万不能使用memcpy进行对象之间的拷贝,因为memcpy是 浅拷贝,否则可能会引起内存泄漏甚至程序崩溃。
2.3 动态二维数组理解
cpp
// 以杨辉三角的前n行为例:假设n为5
void test2vector(size_t n)
{
// 使用vector定义二维数组vv,vv中的每个元素都是vector<int>
aramae::vector<aramae::vector<int>> vv(n);
// 将二维数组每一行中的vecotr<int>中的元素全部设置为1
for (size_t i = 0; i < n; ++i)
vv[i].resize(i + 1, 1);
// 给杨辉三角出第一列和对角线的所有元素赋值
for (int i = 2; i < n; ++i)
{
for (int j = 1; j < i; ++j)
{
vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
}
}
}
aramae::vector<aramae::vector<int>> vv(n); 构造一个vv动态二维数组,vv中总共有n个元素,每个元素都是vector类 型的,每行没有包含任何元素,如果n为5时如下所示:
vv中元素填充完成之后,如下图所示:
使用标准库中vector构建动态二维数组时与上图实际是一致的。
**结语:**感谢相遇
/// 高山仰止,景行行止。虽不能至,心向往之 ///