目录
1、基本成员变量
namespace Fan { template <class T> class vector { public: typedef T* iterator; typedef const T* const_iterator; private: iterator _start; //指向容器的头 iterator _finish; //指向有效数据的尾 iterator _endofstoage; //指向容器的尾 }; }
2、默认成员函数
构造函数
- 1、无参构造函数
我们只需要把每个成员变量初始化为nullptr即可。
//无参构造函数 vector() :_start(nullptr) ,_finish(nullptr) ,_endofstoage(nullptr) {}
- 2、带参构造函数
vector的带参构造函数首先在初始化列表对基本成员变量进行初始化,然后将迭代器区间在[first, last)的数据一个个尾插到容器当中即可。
//带参构造函数 template <class InputIterator> vector(InputIterator first, InputIterator last) :_start(nullptr) , _finish(nullptr) , _endofstoage(nullptr) { //将迭代器区间在[first,last)的数据一个个尾插到容器当中 while (first != last) { push_back(*first); first++; } }
- 3、用n个val去初始化vector
vector的构造函数还支持用n个val去进行初始化,只需要先调用reserve函数开辟n个大小的空间,然后用for循环把val的值依次push_back尾插进去即可。
//用n个val来构造vector vector(size_t n, const T& val = T()) : _start(nullptr) , _finish(nullptr) , _endofstoage(nullptr) { reserve(n); for (size_t i = 0; i < n; i++) { push_back(val); } }
⚠:注意
此时会出现一个问题:内存寻址错误。当我们实现下面的语句时:
Fan::vector<int> v(5, 4);
对于构造函数3而言其两个参数类型为size_t和相对应模板数据类型。而对于构造函数2,其两个参数类型都为迭代器。我们上述代码调用的地方两个参数都是int,此时调用构造函数时匹配的是第二个传迭代器区间的构造函数,导致这样的原因在于编译器会优先寻找最匹配的那个函数。为了解决这一问题,我们还需要重载一个第一个参数类型为int类型的构造函数。
vector(int n, const T& val = T()) : _start(nullptr) , _finish(nullptr) , _endofstoage(nullptr) { reserve(n); for (int i = 0; i < n; i++) { push_back(val); } }
析构函数
首先我们判断该容器_start是否为空,不为空就释放空间+置空即可。
//析构函数 ~vector() { if (_start) //避免释放空指针 { delete[] _start; //释放容量所指向的空间 _start = _finish = _endofstoage = nullptr; //置空 } }
拷贝构造函数
- 传统写法
拷贝构造传统写法的思想是我们最容易想到的:先开辟一块与该容器大小相同的空间,然后将容器当中的数据一个个拷贝过来即可,最后更新_finish和_endofstorage即可。
//传统写法 vector(const vector<T>& v) :_start(nullptr) ,_finish(nullptr) ,_endofstoage(nullptr) { _start = new T[v.capacity()]; //开辟一块和容器V大小相同的空间 for (size_t i = 0; i < v.size(); i++) //将容器v中的数据一个个拷贝过来 { _start[i] = v[i]; } _finish = _start + v.size(); _endofstoage = _start + v.capacity(); }
注意:将容器中的数据一个个拷贝过来时不能够用memcpy函数,当vector存储的数据是内置类型或者是无需深拷贝的自定义类型时,使用memcpy函数并没有什么问题,但是当vector存储的数据是需要进行深拷贝的自定义类型,那么使用memcpy就会存在弊端。例如,当vector存储的数据是string类的时候。
vector当中存储的每一个string都指向自己所存储的字符串。
如果此时我们使用的是memcpy函数进行拷贝构造的话,那么拷贝构造出来的vector当中存储的每个string的成员变量值将与被拷贝的vector当中存储的每个string的成员变量值相同,即两个vector当中的每个对应的string成员都指向同一个字符串空间。
这显然并不是我们想要的结果,那么我们所给的代码是如何解决了这个问题呢?
总结: 如果vector当中存储的数据类型是内置类型(int)或深拷贝的自定义类型(Date),使用memcpy函数进行拷贝构造是没有问题的,但如果vector当中存储的数据类型是深拷贝的自定义类型(string),则使用memcpy函数将不能达到我们想要的结果。
- 现代写法
拷贝构造我们可以仿照string的现代方法拷贝构造思路。首先对基本成员变量进行初始化,然后创建一个tmp的模板将要拷贝的数据利用构造函数传递过去,然后再将这个tmp模板与自己交换即可。
//拷贝构造函数 vector(const vector<T>& v) :_start(nullptr) ,_finish(nullptr) ,_endofstoage(nullptr) { vector<T> tmp(v.begin(), v.end()); //调用构造函数 swap(tmp); }
赋值运算符重载函数
- 传统写法
首先判断是否是给自己赋值,若是给自己赋值则无需进行操作。若不是给自己赋值,则先开辟一块和容器V大小相同的空间,然后将容器V当中的数据一个个拷贝过来,最后更新_finish和_endofstorage的值即可。
//传统写法 vector<T>& operator=(const vector<T>& v) { if (this != &v) //防止自己给自己赋值 { delete[] _start; //释放原来的空间 _start = new T[v.capacity()]; //开辟一块和容器v大小相同的空间 for (size_t i = 0; i < v.size(); i++) //将容器v当中的数据一个个拷贝过来 { _start[i] = v[i]; } _finish = _start + v.size(); //容器有效数据的尾 _endofstorage = _start + v.capacity(); //整个容器的尾 } return *this; //支持连续赋值 }
注意:和拷贝构造的传统写法类似,这里也不能使用memcpy函数进行拷贝。
- 现代写法
我们这里直接用传值传参,不用引用传参。利用vector调用构造函数返回的值与左值swap交换。
//赋值运算符重载 vector<T>& operator=(vector<T> v) //调用构造 { this->swap(v); //交换两个对象 return *this; }
3、容器访问相关函数接口
operator [ ]运算符重载
直接返回pos位置的数据即可进行下标+[ ]的方式进行访问
//operator[]运算符重载 T& operator[](size_t pos) { assert(pos < size()); //检测pos的合法性 return _start[pos]; }
为了方便const对象也可以调用[ ]运算符重载,我们还需要写一个const版本的[ ]运算符重载。
//const版本的[]运算符重载 const T& operator[](size_t pos)const { assert(pos < size()); //检测pos的合法性 return _start[pos]; }
迭代器
vector的begin直接返回容器的_start,end返回容器的_finish。
//begin iterator begin() { return _start; //返回容器的起始位置 } //end iterator end() { return _finish; //返回有效数据下一个的地址 }
const版本:
//const版本迭代器 const_iterator begin()const { return _start; } //end const_iterator end()const { return _finish; }
范围for
现在我们实现了迭代器,实际上也就可以使用范围for遍历容器,因为编译器在编译时会自动将范围for替换成迭代器的形式。
vector<int> v(5, 3); //范围for进行遍历 for (auto e : v) { cout << e << " "; } cout << endl;
4、vector容量和大小相关函数
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 _endofstoage - _start; }
reserve扩容
reserve扩容思路在模拟实现string讲过,这里不再多赘述。
//reserve扩容 void reserve(size_t n) { size_t sz = size();//提前算出size()的大小,方便后续更新_finish if (n > capacity()) { T* tmp = new T[n]; if (_start)//判断旧空间是否有数据 { //不能用memcpy,因为memcpy是浅拷贝 for (size_t i = 0; i < size(); i++) { tmp[i] = _start[i];//将容器当中的数据一个个拷贝到tmp当中 } delete[] _start;//释放旧空间 } _start = tmp;//指向新空间 } //更新_finish和_endofstoage _finish = _start + sz; _endofstoage = _start + n; }
这里有两个需要注意的地方:
- 在进行操作之前需要提前记录当前容器当中有效数据的个数。
因为我们最后需要更新_finish指针的指向,而_finish指针的指向就等于_start指针加上容器当中有效数据的个数,当_start指针的指向改变后我们再调用size函数通过_finish-_start计算出的有效数据的个数就是一个随机值了。此时就会出bug。
- 拷贝容器当中的数据时,不能够使用memcpy函数进行拷贝。
memcpy是浅拷贝,当我们vector当中存储的是string类的时候,使用memcpy函数reserve出来的容器与原容器当中每个对应的string成员都指向同一个字符串空间。当我们释放原容器空间的时候,原容器当中存储的每个string在释放时会调用string的析构函数,将其指向的字符串也进行释放。所以使用memcpy函数reserve出来的容器当中的每一个string所指向的字符串实际上是一块已经被释放的空间,访问该容器时就是对内存空间进行非法访问。
所以我们还是需要用for循环将容器当中的string一个个赋值过来,因为这样能够间接调用string的赋值运算符重载,实现string的深拷贝。
resize
- 如果 n 小于当前容器的size(),则内容将减少到其前 n 个元素,删除超出(并销毁)的元素。
- 如果 n 大于当前容器 size(),则通过在末尾插入所需数量的元素以达到 n 的大小来扩展内容。若指定了 val,则新元素将初始化为 val 的副本,否则,它们将进行值初始化。
- 如果 n 也大于当前容器容量capacity(),则会自动重新分配分配的存储空间。
//resize //void resize(size_t n, T val = T()) void resize(size_t n, const T& val = T()) //利用T()调用默认构造函数的值进行初始化,这样写说明C++的内置类型也有自己的构造函数 { //如果 n > capacity()容量,就需要扩容 if (n > capacity()) { reserve(n); } //如果 n > size(),就需要把有效数据_finish到_start + n之间的数据置为缺省值val if (n > size()) { while (_finish < _start + n) { *_finish = val; _finish++; } } //如果 n < size(),更新有效数据到_start + n else { _finish = _start + n; } }
- 补充:在C++当中内置类型也可以看作是一个类,它们也有自己的默认构造函数,数据类型默认值为0,指针为空。这样也能更好的支持模板,所以我们在给resize函数的参数val设置缺省值时,设置为T()即可。
void test() { int i = 0; int j = int(); int k = int(1); cout << i << endl;//0 cout << j << endl;//0 cout << k << endl;//1 }
swap交换数据
我们直接调用库函数里面的swap去进行成员变量的交换即可。
//交换函数 void swap(vector<T>& v) { std::swap(_start, v._start); std::swap(_finish, v._finish); std::swap(_endofstoage, v._endofstoage); }
empty
empty函数可以直接通过比较容器当中的_start和_finish指针的指向来判断容器是否为空,若指向的位置相同,则该容器为空。
bool empty()const { return _start == _finish; }
5、修改容器内容相关函数
push_back尾插
要尾插首先要判断是否需要扩容,把尾插的值赋过去,再更新有效数据地址_finish即可。
void push_back(const T& x) { //检测是否需要扩容 if (_finish == _endofstoage) { size_t newcapcacity = capacity() == 0 ? 4 : capacity() * 2; reserve(newcapcacity); } *_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()时,就是尾插 }
insert
insert函数可以在所给迭代器pos位置插入数据,在插入数据前先判断是否需要增容,然后将pos位置及其之后的数据统一向后挪动一位,以留出pos位置进行插入,最后将数据插入到pos位置即可。
⚠注意:注意扩容以后,pos就失效了,要记得更新pos,否则就会发生迭代器失效。(迭代器失效问题我们在下一篇文章讲)我们可以通过设定变量n来计算扩容前pos指针位置和_start指针位置的相对距离,最后在扩容后,让_start再加上先前算好的相对距离n就是更新后的pos指针的位置了。
//insert iterator insert(iterator pos, const T& x) { //检测参数合法性 assert(pos >= _start && pos <= _finish); //检测是否需要扩容 /*扩容以后pos就失效了,需要更新一下*/ if (_finish == _endofstoage) { size_t n = pos - _start;//计算pos和start的相对距离 size_t newcapcacity = capacity() == 0 ? 4 : capacity() * 2; reserve(newcapcacity); pos = _start + n;//防止迭代器失效,要让pos始终指向与_start间距n的位置 } //挪动数据 iterator end = _finish - 1; while (end >= pos) { *(end + 1) = *(end); end--; } //把值插进去 *pos = x; _finish++; return pos; }
pop_back尾删
我们首先判断_finish是否大于_start,如果大于,直接_finish--即可,否则什么也不需要操作。
void pop_back() { if (_finish > _start)//判断是否可以进行删除 { _finish--; } }
pop_back也可以复用下文的erase实现,当erase的参数为_finish时,实现的就是尾删,而_finish可以通过调用迭代器end()函数来解决。
void pop_back() { //法二:复用erase erase(end() - 1); //不能用end()--,因为end()是传值返回,返回的是临时对象,临时对象具有常性,不能自身++或--,因此要用end() - 1 }
erase
首先要检查删除位置pos的合法性,其次从pos+1位置开始往前覆盖即可删除pos位置,最后返回的值为删除位置的下一个位置,其实返回的就是pos,因为在pos删除后,下一个值会覆盖到pos的位置上。
//erase iterator erase(iterator pos) { //检查合法性 assert(pos >= _start && pos < _finish); //从pos + 1的位置开始往前覆盖,即可完成删除pos位置的值 iterator it = pos + 1; while (it < _finish) { *(it - 1) = *it; it++; } _finish--; return pos; }
- 补充1:
一般vector删除数据,都不考虑缩容的方案,当size() < capacity() / 2 时,可以考虑开一个size()大小的新空间,拷贝数据,释放旧空间。缩容的本质是时间换空间。一般设计不会考虑缩容,因为实际比较关注时间效率,不是太关注空间效率,因为现在硬件设备空间都比较大,空间存储也比较便宜。
- 补充2:
- erase也会存在迭代器失效,erase的失效是意义变了,或者不存在有效访问数据范围。
- 一般不会使用缩容的方案。那么erase的失效一般也就不存在野指针导致的失效。
- erase(pos)以后pos失效了,pos的意义变了,但是在不同平台下面对于访问pos的反应是不一样的,我们用的时候要以失效的角度去看待此问题。
- 对于insert和erase造成迭代器失效问题,linux的g++平台检查很佛系,基本靠操作系统本身野指针越界检查机制。windows下VS系列检查更严格一些,使用一些强制检查机制,意义变了可能会检查出来。
- 虽然g++对于迭代器失效检查时是非常佛系的,但是套在实际场景中,迭代器意义变了,也会出现各种问题。
clear清空数据
只需要把起始位置的指针_start赋给有效数据指针_finish即可完成数据的清空。
//clear清空数据 void clear() { _finish = _start; }