目录
2.1 _start、_finish、_end_of_stroage 的说明
1.vector的介绍及使用
1.1 vector的介绍
1. vector是表示可变大小数组的序列容器。
2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小为了增加存储空间。其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
6. 与其它动态序列容器相比（deque, list and forward_list）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起list和forward_list统一的迭代器和引用更好。
1.2 vector的使用
1.2.1 vector的初始化
构造函数
使用举例：
vector<int> v1(10,0); // 开辟 10 个 int 类型的空间，全部初始化为 0
vector<int> v1(10); // 开辟 10 个 int 类型的空间，全部初始化为 0
vector<string> v2(10,"***"); // 开辟 10 个 string 类对象的空间，全部初始化为 ***
vector<int> v3(v1.begin(),v1.end()); // 用自己的迭代器初始化
string s("***");
vector<char> v4(s.begin(),s.end()); // 用其他容器的迭代器初始化
int a[4] = { 1 , 2 , 3 , 4 };
vector<int> v4(a,a + 4); // 用数组名初始化
// 3行4列，所有元素为0
vector<vector<int>> matrix(3, vector<int>(4));
// 3行4列，所有元素初始化为特定值（如-1）
vector<vector<int>> matrix(3, vector<int>(4, -1));
// 直接初始化元素
vector<vector<int>> matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// 或者省略等号
vector<vector<int>> matrix{
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// 用一维构建二维
vector<int> row1 = {1, 2, 3};
vector<int> row2 = {4, 5, 6};
vector<vector<int>> matrix = {row1, row2};
vector<vector<int>> matrix;
// 添加行
matrix.push_back({1, 2, 3});
matrix.push_back(vector<int>(3, 0)); // 添加一行3个0
matrix.emplace_back(4, 5); // 添加一行 {4, 5}
// 不规则二维 vector（每行长度不同）
vector<vector<int>> jagged = {
{1},
{2, 3},
{4, 5, 6}
};
// c 风格的 vector 数组
vector<int> arr[10]; // 定义一个普通数组，每个元素都是一个一维vector,相当于二维数组1.2.2 排序
包含 <algorithm> 头文件，使用 sort 函数进行排序：
vector<int> v;
v.push_back(23);
v.push_back(67);
v.push_back(99);
v.push_back(36);
int a[4] = { 45,26,78,95 };
sort(v.begin,v.end); // 排升序
sort(v.rbegin,v.rend); // 排降序
sort(v.begin,v.end,greater<int>()); // 排降序
sotr(a,a+4); // 对数组排序1.2.3 vector 空间增长问题
capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL。
易错点
使用 [ ] 访问 vector 容器时，只能在 size 以内的地方访问，而不是在开辟的空间内对任意位置进行访问。(operator[] 函数会检查下标是否小于 size ( assert( i < _size);)）
错误演示：
vector v;
v.reserve(10); // size = 0; capacity = 10;
for(int i = 0; i < 10; i++)
{
v[i] = i; // 错误，无法访问 v[0]
}
//v.resize(10);
//for(int i = 0; i < 10; i++)
//{
// v[i] = i; // 正确
//}
//for(int i = 0; i < 10; i++)
//{
// v.push_back(i); // 正确
//}1.2.4 vector 的增删查改
1.2.5 迭代器失效问题
迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对指针进行了封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效实际就是迭代器底层对应指针所指向的空间被销毁了，而迭代器继续使用一块已经被释放的空间，造成的后果是程序崩溃
删除某个特定的数据：
包含头文件 <algorithm> ，使用 find 函数找到 vector 中第一个 3，并删除它：
// 删除3,但是不知道3在哪个位置,怎么办?
vector<int>::iterator pos = find(v1.begin(), v1.end(), 3);
// auto pos = find(v1.begin(), v1.end(), 3);
if (pos != v1.end())
{
v1.erase(pos);
}
删除 vector 中的所有的 3：
auto pos = find(v1.begin(), v1.end(), 3);
while(pos != v1.end())
{
v1.erase(pos);
pos = find(v1.begin(), v1.end(), 3);
}erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。
对于vector可能会导致其迭代器失效的操作有：
1. 会引起其底层空间改变的操作，都有可能造成迭代器失效，比如：resize、reserve、insert、assign、push_back等。在使用这些函数之后，一律认为迭代器已失效。
2.指定位置元素的删除操作--erase：vs 下 erase 之后不管迭代器是否失效，再访问该迭代器程序都会崩溃，linux 下不会。建议在使用 erase 函数之后接收它的返回值（删除位置的下一个元素）这样可以增加代码的可移植性，it = v.erase(it); 。注意：erase 的返回的迭代器虽然指向的地址没有变，但它指向的是被删除的元素的下一个位置。erase操作不光会导致指向被删除元素的迭代器失效，删除元素后面的迭代器也会失效
注意：Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。
// 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 之后，迭代器也会失效#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.模拟实现
2.1 _start、_finish、_end_of_stroage 的说明
代码实现
头文件
由于vector采用类模板，所以函数的声明和定义都放在了头文件。
#pragma once
#include <assert.h>
#include <string.h>
namespace Myvector
{
template<class T>
class vector
{
public:
// Vector的迭代器是一个原生指针
typedef T* iterator;
typedef const T* const_iterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator cbegin() const
{
return _finish;
}
const_iterator cend() const
{
return _start;
}
// construct and destroy
vector();
vector(int n, const T& value = T());
template<class InputIterator>
vector(InputIterator first, InputIterator last)
{
assert(first != nullptr && last != nullptr);
reserve(last - first + 1);
while (first != last + 1)
{
push_back(*(first));
first++;
}
}
vector(const vector<T>& v)
{
_start = new T[v.capacity()];
// 不能使用memcpy，
//假如 T 实例化后是 string，
//memcpy只是把每个 string 的 _str 的值拷贝，是浅拷贝
for (int i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
// 假如 T 实例化后是 string,v.
// v._start[i] 是一个 string 对象，
// _start[i] 也是一个 string 对象，
// 此时会调用 string 的拷贝构造函数完成深拷贝
}
_finish = _start + v.size();
_endOfStorage = _start + v.capacity();
}
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
~vector();
// capacity
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _endOfStorage - _start;
}
void reserve(size_t n)
{
if (n > capacity())
{
size_t sz = size();
iterator tmp = new T[n];
//memcpy(tmp, _start, capacity() * sizeof(T)); error
for (size_t i = 0; i < size(); i++)
{
*(tmp + i) = *(_start + i);
}
delete[] _start;
_start = tmp;
_finish = _start + sz;
_endOfStorage = _start + n;
}
}
// T():匿名对象，int 也有构造函数
void resize(size_t n, const T& value = T())
{
if (n < size())
{
_finish = _start + n;
}
if (n > size())
{
reserve(n);
size_t count = n - size();
while (count--)
{
*(_finish) = value;
_finish++;
}
}
}
///////////////access///////////////////////////////
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
const T& operator[](size_t pos)const
{
assert(pos < size());
return _start[pos];
}
///////////////modify/////////////////////////////
void push_back(const T& x)
{
if (size() == capacity())
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
}
*(_start + size()) = x;
_finish++;
}
void pop_back()
{
assert(size());
_finish--;
}
void swap(vector<T>& v)
{
iterator tmp = v._start;
v._start = _start;
_start = tmp;
tmp = v._finish;
v._finish = _finish;
_finish = tmp;
tmp = v._endOfStorage;
v._endOfStorage = _endOfStorage;
_endOfStorage = tmp;
}
iterator insert(iterator pos, const T& x)
{
assert(pos < _finish);
size_t n = pos - _start;
if (_finish == _endOfStorage)
{
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = _start + n;
}
// 挪数据
iterator i = _finish - 1;
while (i != pos - 1)
{
*(i + 1) = *i;
i--;
}
*pos = x;
_finish++;
return pos;
}
iterator erase(iterator pos)
{
assert(pos < _finish);
iterator i = pos + 1;
while (i != _finish)
{
*(i - 1) = *i;
i++;
}
_finish--;
return pos;
}
private:
iterator _start; // 指向有效数据的开始
iterator _finish; // 指向最后一个有效数据的下一个
iterator _endOfStorage; // 指向开辟空间最后一个元素的下一个位置
};
// 类模板的成员函数定义要放在同一个文件，不能分离！！！
template<class T> // 类模板的成员函数在类外定义要加模板参数！！！
vector<T>::vector() :// vector是类名，vector<T>才是类型名！！！
_start(nullptr),
_finish(nullptr),
_endOfStorage(nullptr)
{}
template<class T> // 每次都要声明模板参数
vector<T>::vector(int n, const T& value)
{
if (_start == nullptr)
{
_start = new T[n];
}
for (int i = 0; i < n; i++)
{
*(_start + i) = value;
}
_finish = _start + n;
_endOfStorage = _finish;
}
// 对于类模板，如果不 显式 定义析构函数，可能会导致链接错误
template<class T>
vector<T>::~vector()
{
if (_start != nullptr)
{
delete[] _start;
}
_start = _finish = _endOfStorage = nullptr;
}
}
扫一扫
3693
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
