vector的模拟实现
文章目录
一、vector模拟实现总览
vector中有三个成员变量分别是_ start、_ finish、_endofstorage,他们的类型均为迭代器。
_ start 指向容器的头,_ finish 指向有效数据的尾,_endofstorage 指向整个容器的尾。
namespace vector_realize { //模拟实现vector template<class T> class vector { public: typedef T* iterator; typedef const T* const_iterator; //默认成员函数 vector(); //无参构造函数 vector(size_t n, const T& val); //带参构造函数 template<class InputIterator> vector(InputIterator first, InputIterator last); //迭代器构造函数 vector(const vector<T>& v); //拷贝构造函数 vector<T>& operator=(const vector<T>& v); //赋值运算符重载函数 ~vector(); //析构函数 //迭代器相关函数 iterator begin(); iterator end(); const_iterator begin() const; const_iterator end() const; //容量和大小相关函数 size_t size() const; size_t capacity() const; void reserve(size_t n); void resize(size_t n, const T& val = T()); bool empty() const; //修改容器内容相关函数 void push_back(const T& x); void pop_back(); void insert(iterator pos, const T& x); iterator erase(iterator pos); void swap(vector<T>& v); //访问容器相关函数 T& operator[](size_t pos); const T& operator[](size_t pos) const; T& front(); T& back(); const T& front() const; const T& back() const ; private: iterator _start; //指向容器的头 iterator _finish; //指向有效数据的尾 iterator _endofstorage; //指向容器的尾 }; }
二、模拟实现vector函数接口
1. 默认成员函数
1.1. 构造函数
- 1、无参构造函数
vector容器支持一个无参构造函数,这里我们只需要把每个成员变量初始化为空指针即可。
// 构造函数 vector() // --> 无参构造函数 :_start(nullptr) ,_finish(nullptr) ,_endofstorage(nullptr) {}
- 2、带参构造函数
vector的带参构造函数首先在初始化列表对基本成员变量初始化,在将迭代器区间在[first, last)的数据一个个尾插到容器当中即可:
// --> 迭代器构造 // 若使用iterator做迭代器,会导致初始化的迭代器区间[first,last)只能是vector的迭代器 // 重新声明迭代器,迭代器区间[first,last)可以是任意容器的迭代器 template<class InputIterator> vector(InputIterator first, InputIterator last) :_start(nullptr) ,_finish(nullptr) ,_endofstorage(nullptr) { while (first != last) { push_back(*first); first++; } }
- 3、用n个val去初始化vector
vector的构造函数还支持用n个val去初始化,只需要先调用reserve函数开辟n个大小的空间,再利用for循环把val的值依次push_back尾插进去即可。
// 带参构造函数 --> 初始化容器为n个val vector(size_t n, const T& val = T()) :_start(nullptr) ,_finish(nullptr) ,_endofstorage(nullptr) { reserve(n); for (size_t i = 0; i < n; i++) { push_back(val); } }
这样写会出现一个问题:内存寻址错误。当我想实现下面的语句时:
vector<int> v1(10, 5); vector<char> v2(10, 'A');
这里我调用的地方两个参数都是int,此时调用构造函数时匹配的是第二个传迭代器区间的构造函数,导致这样的原因在于编译器会优先寻找最匹配的那个函数。此构造函数的第一个参数是unsigned int类型,所以不会优先匹配此构造函数。因此我们需要再重载一个第一个参数为int类型的构造函数即可解决,并且STL库里面也重载long版本,这里一并加上。
// 重载1 vector(long n, const T& val = T()) :_start(nullptr) , _finish(nullptr) , _endofstorage(nullptr) { reserve(n); for (size_t i = 0; i < n; i++) { push_back(val); } } // 重载2 vector(int n, const T& val = T()) :_start(nullptr) , _finish(nullptr) , _endofstorage(nullptr) { reserve(n); for (int i = 0; i < n; i++) { push_back(val); } }
1.2. 析构函数
析构容器时,应该先判断容器是否为空,如果为空,则不需要析构操作。如果不为空,则先释放容器的存储空间,然后将各个成员变量赋值为空指针即可。
//析构函数 ~vector() { if(_start) { delete[] _start; _start = _finish = _endofstorage = nullptr; } }
1.3.拷贝构造函数(深拷贝)
拷贝构造这里同样涉及深拷贝,有这里我们仍然提供两种写法:传统写法和现代写法。
- 1、传统写法:
传统写法就是先开辟一块与原来容器大小相同的空间,然后将容器中的数据一个一个拷贝过来即可,最后更新_ finish 和 _ endofstorage 即可。
//拷贝构造函数 // 拷贝构造 v1(v) // 传统写法 vector(const vector<T>& v) :_start(nullptr) ,_finish(nullptr) ,_endofstorage(nullptr) { _start = new T[capacity()]; // 开辟一块和v大小相同的空间 // memcpy(_start, v._start, sizeof(T) * size()); error for (size_t i = 0; i < size(); i++) { _start[i] = _v[i]; } _finish = _start + size(); _endofstorage = _start + capacity(); }
注意:这里不能用memcpy拷贝数据,原因下一篇博客细讲。
- 2、现代方法:
我们在string类的现代方法知道,要完成深拷贝,自己不想完成,就让别人完成,然后和别人互换劳动成果。vector也是一样。
假设我要用v1拷贝v2,首先对基本成员变量进行初始化,然后我创建tmp对象将要拷贝的数据利用构造函数去传递过去,再利用swap函数把tmp对象的成员函数全部与v1交换即可完成现代方法的深拷贝。
// 现代写法1 vector(const vector<T>& v) :_start(nullptr) ,_finish(nullptr) ,_endofstorage(nullptr) { vector<T> tmp(v.begin(), v.end()); // 调用迭代器构造函数 swap(tmp); }
还有一种比较巧妙的方法,使用范围for(其他遍历方式也行)对容器v进行遍历,在遍历过程中将容器v中的数据一个一个尾插进去即可。
// 现代写法1 vector(const vector<T>& v) :_start(nullptr) ,_finish(nullptr) ,_endofstorage(nullptr) { reverse(v.capacity()); for (const auto& e : v) { push_back(e); } }
注意:范围for这里一定要加上引用,不加引用会发生拷贝,如果是自定义类型的话,会调用拷贝构造,时间空间开销都比较大,如果是浅拷贝可能还有其他问题。并且引用可以节省内存空间,提高效率。
1.4. 赋值运算符重载函数
vector的赋值运算符重载也涉及深拷贝问题,这里我们依然有传统方法和现代方法。
- 1、传统写法:
- 思路:
首先仍然是判断是否自己给自己赋值,自己给自己赋值倒是不会报错,但是会付出代价,比如又重新开辟一块内存空间,然后进行深拷贝,消耗了时间和空间。所以我们尽量避免。如果不是自己给自己赋值,那么我们先开辟一块和容器一样大的空间,然后将容器v中的数据一个一个拷贝过来,之后释放原来的空间,更新新空间的地址。最后更新_ finish 和_ endofstorage。
//赋值运算符重载 --> 深拷贝 // 传统写法 // v1 = v; 赋值重载 v1.operator=(&v1, v); vector<T>& operator=(const vector<T>& v) { if (this != &v) // 防止自己给自己赋值 { T* tmp = new T[capacity()]; // memcpy(tmp, _start, sizeof(T) * size()); ——> 浅拷贝问题,不能使用 for (size_t i = 0; i < size(); i++) { tmp[i] = _start[i]; // 调用T类的赋值运算符重载函数进行深拷贝 } delete[] _start; _start = tmp; _finish = _start + size(); _endofstorage = _start + capacity(); } return *this; }
- 注意:
1、这里我们不能使用memcpy,浅拷贝会导致程序报错,这个内容我们下一篇会重点讲解。
2、C语言的动态开辟内存malloc需要检查合法性,而C++的new不需要,new失败的话需要抛异常捕获。
- 2、现代写法:
我们在学习string类的时候实现了赋值运算符重载的现代方法,本质就是剥削,vector也是一样,找到一个中间变量,让他去完成深拷贝,我们直接与他交换,白嫖了人家的劳动成果。这里的现代方法和上文拷贝构造的现代方法差不多,只不过多了一个返回值。具体操作如下:
//法一:基础版 // 拷贝构造 vector<T>& operator=(const vector<T>& v) { if (this != &v) { //vector<T> tmp(v.begin(), v.end()); // 构造函数 vector<T> tmp(v); // 拷贝构造 swap(tmp); } return *this; }
这里还有另一种更加简洁的现代方法,上述写法是引用传参,这里我们可以直接传值传参,让编译器自动调用拷贝构造函数,再把拷贝出来的对象作为右值与左值交换即可。传值并没有权限放大问题,所以不需要const修饰,权限问题出现在指针和引用的使用中。
// 简化版 -- 不能检查自己给自己赋值 // v1 = v2; // v1 = v1; vector<T>& operator=(vector<T> v)//传值传参调用拷贝构造 { swap(v); return *this; }
不过这种简洁的版本无法避免自己给自己赋值,但很少会出现自己给自己赋值的行为,即使出现这种行为,程序也并不报错,所以我们也可以使用这种方法。
2. 容量操作函数
2.1. size和capacity
指针相减可以得到对应的个数,因此获取size只需_ finish - _ start。获取capacity只需_ endofstoage - _ start。
- size函数:
size_t size() const //最好加上const,普通对象和const对象均可调用 { return _finish - _start; //指针相减就能得到size的个数 }
- capacity函数:
size_t capacity() const { return _endofstorage - _start; }
2.2. resize
resize扩容规则:
- 如果 n 大于当前容器的capacity(),则重新分配一块更大的存储空间,并把原来的数据原封不动的拷贝过来。
- 如果 n 大于当前容器 size(),则通过在末尾插入所需数量的元素来扩展内容,以达到 n 的大小。如果指定了 val,则新元素将初始化为 val 的副本,否则,它们将被值初始化。
- n 大于当前容器 size(),则内容将减少到其前 n 个元素,删除超出的元素(并销毁他们)。
//假如size = 5, capacity = 10 // n > 10 扩容+填充数据 // 5 < n <= 10 填充数据 // n <= 5 删除数据 //利用T()匿名对象调用默认构造函数的值进行初始化,这样写说明C++的内置类型也有自己的构造函数 void resize(size_t n, T val = T()) { // 1.空间不够增容 if (n > capacity()) { reserve(n); } // 2.n > size(),填充数据,将size()扩大到n //然后把有效数据_finish到_start + n之间的数据置为缺省值val if (n > size()) { while (_finish < _start + n) { *_finish = val; _finish++; } } else { //3.n < size(), 将数据个数缩小到n _finish = _start + n; } }
- **补充:**C++的内置类型也有自己的构造函数和析构函数,这样才能更好的支持模板。
void test() { int i = 0; int j = int(); int k = int(2); cout << i << endl;//0 cout << j << endl;//0 cout << k << endl;//2 }
2.3. reserve
reserve扩容规则:
- 如果 n 大于当前容器的capacity(),则该函数会导致容器重新分配其存储空间,将其capacity()增加到 n(或更大)。
- 在所有其他情况下,函数调用不会导致重新分配,并且容器的capacity()不受影响。
reserve扩容和string的扩容非常相似。先判断参数n是否大于当前容器的capacity()(否则不做任何操作),如果大于当前容器的capacity(),先开辟一块新的扩容的空间,如果原来的空间里面有数据,那么就利用for循环将容器中的数据一个一个拷贝到新空间,再释放旧空间,最后指向新空间。如果没有,直接指向新空间即可。
//reserve扩容 void reserve(size_t n) { int oldSize = size(); if (capacity() < n) { // 1.开辟新空间 T* tmp = new T[n]; if (_start) { //2.拷贝元素 // 这里直接用memcpy会有问题,发生浅拷贝 //memcpy(tmp, _start, sizeof(T) * size()); for (size_t i = 0; i < oldSize; i++) { tmp[i] = _start[i]; // 本质调用赋值运算符重载进行深拷贝 } //3. 释放旧空间 delete[] _start; } _start = tmp; } // 这里_start的地址变了,而_finish还是原来的位置 //_finish = _start + size(); error _finish = _start + oldSize; _endofstorage = _start + n; }
- 补充1:
在扩容结束后要记得更新_ finish和_ endofstoage,这里的_ finsh要加上原先的size()长度,要先用变量oldSize保存下来,否则之后扩容后会更改指针的指向由原先的_start变为tmp,这里直接+ size()函数的返回值会导致结果为随机值。
- 补充2:
不能使用memcpy进行数据拷贝,因为memcpy是浅拷贝,它会将一段内存空间中内容原封不动的拷贝到另外一段内存空间中,导致后续delete时拷贝过的数据一并给delete了,具体我下篇博客细讲。
2.4. empty
empty函数可以直接比较当前容器中的_ start 和 _ finish指针是否相等来判断容器是否为空,若相等,则为空,反正,不为空。
bool empty() const { return _start == _finish; }
3. 修改操作函数
3.1. push_back
push_back尾插和之前写过的尾插没什么区别,先判断是否需要扩容,然后把尾插的值赋值过去,最后更新有效数据地址_ finish即可:
void push_back(const T& x) { // 判断是否需要扩容 if (_finish == _endofstorage) { int newCapacity = capacity() == 0 ? 4 : capacity() * 2; reserve(newCapacity); } *_finish = x; _finish++; }
这里push_back还可以复用下面实现好的insert进行尾插,当insert中的pos为_ finish时,insert实现的就是push_back尾插。而_finish可以通过调用迭代器end函数来解决。
void push_back(const T& x) { //法二:复用insert insert(end(), x); //当insert中的参数pos为end()时,就是尾插 }
3.2. pop_back
首先判断_ finish是否大于_ start,若大于,直接_finsh–即可,也可以调用 !empty()函数,若容器为空,则不需要操作。
void pop_back() { //判断是否可以进行删除 if (_finish > _start) { _finish--; } /*assert(!empty()); _finish--;*/ }
pop_back也可以复用下文的erase实现,当erase的参数为_ finish时,实现的就是尾删,而_ finish可以通过调用迭代器end()函数来解决。
void pop_back() { //法二:复用erase erase(end() - 1); //不能用end()--,因为end()是传值返回,返回的是临时对象,临时对象具有常性,不能自身++或--,因此要用end() - 1 }
3.3. insert
首先要检查插入的位置是否越界,再插入数据之前判断是否需要扩容。之后再挪动数据,最后把值插入指定位置。
- 注意:
注意扩容以后,pos就失效了,要记得更新pos,否则会发生迭代器失效。可以通过设定变量len来计算扩容前pos指针位置和_ start指针位置的相对距离,最后在扩容后,让_start再加上先前算好的相对距离len,就得到了更新后的pos指针的位置了。其实这里还有一个迭代器失效的问题,我们下一篇迭代器失效的博客再细讲。下面给出优化修改后的insert:
// 迭代器失效 : 野指针问题 // 不能保证原地扩容,扩容就会导致迭代器失效:地址变化了 iterator insert(iterator pos, const T& val) { assert(pos >= _start); assert(pos <= _finish); // aasert(pos >= _start && pos <= _finish); 这样也可以,不过无法快速判断哪个原因 if (_finish == _endofstorage) { size_t len = pos - _start; int newCapacity = capacity() == 0 ? 4 : capacity() * 2; reserve(newCapacity); // 扩容会导致迭代器失效,需要重新修改数据pos pos = _start + len; } // 挪动数据 iterator end = _finish - 1; while (end >= pos) { *(end + 1) = *end; end--; } // 插入数据 *pos = val; _finish++; return pos; }
3.4. erase
首先要检查删除位置pos的合法性,其次从pos + 1的位置开始往前覆盖即可删除pos位置,最后记得返回的值为删除位置的下一个位置,其实返回的就是pos,因为在pos删除后,下一个值会覆盖到pos的位置上。
iterator erase(iterator pos) { assert(pos >= _start); assert(pos < _finish); iterator begin = pos + 1; while (begin < _finish) { *(begin - 1) = *begin; begin++; } _finish--; return pos; //返回pos的下一个位置 }
- 补充1:
一般vector删除数据,都不考虑缩容的方案,当size() < capacity() / 2 时,可以考虑开一个size()大小的新空间,拷贝数据,释放旧空间。缩容的本质是时间换空间。一般设计不会考虑缩容,因为实际比较关注时间效率,不是太关注空间效率,因为现在硬件设备空间都比较大,空间存储也比较便宜。
- 补充2:
- erase也会存在失效,erase的失效是意义变了,或者不存在有效访问数据有效范围。
- 一般不会使用缩容的方案,那么erase的失效,一般也不存在野指针的失效。
下一篇博客会仔细分析迭代器失效问题,这里先给出结论:
- erase(pos)以后pos失效了,pos的意义变了,但是在不同平台下面对于访问pos的反应是不一样的,我们用的时候要以失效的角度去看待此问题。
- 对于insert和erase造成迭代器失效问题,linux的g++平台检查并不是很严格,基本靠操作系统本身野指针越界检查机制。windows下VS系列检查更严格一些,使用一些强制检查机制,意义变了可能会检查出来。
- 虽然g++对于迭代器失效检查时是并不严格,但是套在实际场景中,迭代器意义变了,也会出现各种问题。
3.5. swap
swap函数用于交换两个容器的数据,我们可以直接调用库里面的swap函数将两个容器当中的各个成员变量进行交换即可。
//交换函数 void swap(vector<T>& v) { std::swap(_start, v._start); std::swap(_finish, v._finish); std::swap(_endofstoage, v._endofstoage); }
- 补充1:
在调用库里面的swap的时候需要加上std::(作用域限定域),编译器这里优先在库里面寻找swap函数,否则编译器会根据就近原则,调用命名空间你自己实现的swap函数。
- 补充2:
这里我们在传参的时候不能加上const修饰,因为swap交换两个对象,导致容器v的内容改变了。
3.6. clear
只需要把起始位置的指针_ start赋给有效数据指针_ finish即可完成数据的清空。
//clear清空数据 void clear() { _finish = _start; }
4.元素访问函数
4.1. operator[ ]运算符重载
直接返回pos位置的数据即可进行下标+[ ]的方式进行访问。
//operator[]运算符重载 T& operator[](size_t n) { assert(n < size()); return _start[n]; }
为了方便const对象也可以调用[ ]运算符重载,因此还推出了一个const版本的[ ]运算符重载。
const T& operator[](size_t n) const { assert(n < size()); return _start[n]; }
4.2. front和back
front访问第一个元素,back访问最后一个元素这两个没什么用,因为可以用operator[]代替,大家知道就行了。
T& front() { return *_start; } T& back() { return *(_finish - 1); }
为了方便const对象也可以调用,因此还推出了一个const版本的访问函数。
const T& front() const { return *_start; } const T& back() const { return *(_finish - 1); }
5.迭代器
vector的begin直接返回容器的_ start起始位置即可,vector的end返回容器的_finish的位置。
typedef T* iterator; iterator begin() { return _start; } iterator end() { return _finish; }
这里迭代器同样也要考虑到const对象调用的可能性,使得const对象调用begin()和end()函数时得到的迭代器只能对数据进行只读操作,不能修改。因此推出const版本的迭代器如下:
//const版本迭代器 typedef const T* const_iterator; const_iterator begin() const { return _start; } const_iterator end() const { return _finish; }
这里大家在看vector使用迭代器的代码就会非常清晰,实际就是使用指针遍历容器,如下:
vector<int> v(10, 1); vector<int>::iterator it = v.begin(); while(it != v.end()) { cout << *it << " " it++; } cout << endl;
我们之前说过范围for的底层是迭代器,我们实现了迭代器,也可以使用范围for遍历容器,因为在编译器编译时会自动将范围for替换为迭代器的形式,记住这是傻瓜式的替换,意思是你的迭代器不能修改,比如我们把begin变成Begin,这时候范围for就编译不过去了。
vector<int> v(10, 1); for(auto e : v) { cout << e << " "; } cout << endl;