目录
前言
本文后面关于反向迭代器的操作会涉及到前面的文章~
一.deque的常用接口
deque可以说是结合了容器vector与list的所有特点~
二.deque的原理
2.1 vector与list的优缺点
vector:优~缺~点
- 支持随机访问
- 缓存命中（物理空间连续）
- 浪费空间（扩容多余）
- 前面部分插入删除效率低
list：优~缺~点
- 不支持随机访问
- 缓存命中低（物理空间非连续）
- 空间按需申请与释放
- 任意位置插入删除效率高
最后发现，二者可以说是互补的表现
2.2 deque的原理
其实融合两大容器特点的deque并不像我们想象中那样，它本质是通过存储在指针数组的指针来管理数据的~一般buff数组满了不会直接扩容，而是开辟一个新的空间，然后我们在到指针数组中添加一个指针去指向新空间，这也是为什么先在居中位置的原因~（要给前面与后面的指针留空间）
而我们在已满条件头插时也不是从buff数组头部开始，而是在尾部，与下一处空间保持衔接性~
而这种结构的优缺点也很明显~
- 头插头删，尾插尾删很方便
- 当我们尝试随机访问时（例如访问第i个的数据），我们以buff容量全为10为例~
- 若全部buff容量已满，i/10代表访问第i个buff~在第i个buff中 i%10代表求出我们想要访问的数据位置
- 若第一个buff容量仍不满，i-=第一个buff中的数据个数，后面再重复上一步
- 当我们尝试中间删除时，若想保持buff容量，则挪动数据。若不想保持，则扩容。
最后我们发现实在是奇怪，两个缺点都有着互相矛盾的地方，很麻烦就是了，而这也是dequeue虽然有两个容器的特点，但终究不是主流的原因。也只有当我们想要多次进行头插头删，尾插尾删这些操作的时候才会想去用它~
不过人家的迭代器很强大，大家可以了解一下~
三.反向迭代器
在学习反向迭代器之前我们先来测试一下原生指针与我们自定义的指针有何区别~
可以发现最开始的指向都是一致的，没有问题。但是二者*解引用以及运算符++后就会有所区别了~
如果我们想要调用反向迭代器，那我们就需要和iterator一样用类去封装反向迭代器，还要再加入const版本~
反向迭代器与正向迭代器不一样的就是把++当成--，把--当成++。其他都一样~
但最后也只是实现了服务于容器List的反向迭代器~有没有一种方法可以让反向迭代器适用所有的容器呢？
我们来写一个关于反向迭代器适配容器的文件~
#pragma once template<class Iterator, class Ref, class Ptr> struct ReverseIterator { typedef ReverseIterator<Iterator, Ref,Ptr> Self; Iterator cur;//创建正向迭代器类对象 ReverseIterator(Iterator it)//通过正向迭代器对象构造并初始化对象 :cur(it) {} Self& operator++() { --cur;//调用正向迭代器的--接口 return *this; } Self& operator--() { ++cur;//调用正向迭代器的++接口 return *this; } Ref operator*() { Iterator tmp = cur;//因为反向迭代器对称的特性，后面需要前置--，而解引用不需要迭代器移动，所有用临时对象来搞 --tmp; return *tmp; } Ptr operator->() { return &(operator*());//->实际上是两个，这里只需要返回解引用后的地址即可 例如*返回AA，那么&AA就是AA*了 } bool operator!=(const Self& s) { return cur != s.cur; } };在这里会发现，比起直接拷贝复制正向迭代器的代码，不如直接复用它~核心就是通过正向迭代器来构建我们的反向迭代器，而与正向迭代器的不同之处我们也可以在复用它的同时稍微做出一些修改即可。比如运算符++我们就调用正向迭代器的--，运算符--就调用正向迭代器的++。而解引用由于反向迭代器的特殊性，我们再额外做出修改就好了~
这样就相当于我们写了一套反向迭代器的模板，核心在于复用正向迭代器，更精妙的是正向迭代器的所属容器也可以让反向适用。比如我们是写了一个关于容器vector的正向迭代器，那么我们可以通过类模板把正向迭代器传输给反向迭代器，反向迭起器通过复用传输过来的正向迭代器也形成了服务于容器vector的特性~
四.全部代码
//ReverseIterator.h
#pragma once
template<class Iterator, class Ref, class Ptr>
struct ReverseIterator
{
typedef ReverseIterator<Iterator, Ref,Ptr> Self;
Iterator cur;//创建正向迭代器类对象
ReverseIterator(Iterator it)//通过正向迭代器对象构造并初始化对象
:cur(it)
{}
Self& operator++()
{
--cur;//调用正向迭代器的--接口
return *this;
}
Self& operator--()
{
++cur;//调用正向迭代器的++接口
return *this;
}
Ref operator*()
{
Iterator tmp = cur;//因为反向迭代器对称的特性，后面需要前置--，而解引用不需要迭代器移动，所有用临时对象来搞
--tmp;
return *tmp;
}
Ptr operator->()
{
return &(operator*());//->实际上是两个，这里只需要返回解引用后的地址即可 例如*返回AA，那么&AA就是AA*了
}
bool operator!=(const Self& s)
{
return cur != s.cur;
}
};//list.h
#pragma once
#include <assert.h>
#include"ReverseIterator.h"
namespace lj
{
template <class T>
struct ListNode
{
ListNode<T>* _next;
ListNode<T>* _prev;
T _Data;
//构造初始化 利用匿名对象调用该类型的构造函数
ListNode<T>(const T& x = T())
{
_next = nullptr;
_prev = nullptr;
_Data = x;
}
};
template <class T,class Ref,class Ptr>
struct _list_iterator
{
typedef ListNode<T> Node;
typedef _list_iterator<T,Ref,Ptr> self;
Node* _node;
//构造函数
_list_iterator(Node* node)
{
_node = node;
}
//前置++
self& operator++()
{
//不再是单纯的自加1，而是指向下一位置
_node = _node->_next;
return *this;
}
//后置++
self operator++(int)
{
self tmp(*this);
_node = _node->_next;
return tmp;
}
//前置--
self& operator--()
{
_node = _node->_prev;
return *this;
}
//前置--
self operator--(int)
{
//拷贝一份--前的数据
self tmp(*this);
_node = _node->_prev;
return tmp;
}
//解引用
Ref operator*()
{
return _node->_Data;
}
//指针与指针的对比！=
bool operator!=(const self& x)
{
return _node != x._node;
}
//指针与指针的对比==
bool operator==(const self& x)
{
return _node == x._node;
}
Ptr operator->()
{
return &_node->_data;
}
};
template <class T>
class list
{
typedef ListNode<T> Node;
public:
typedef _list_iterator<T,T&,T*> iterator;
typedef _list_iterator<T,const T&,T*> const_iterator;
typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;
reverse_iterator rbegin()
{
return reverse_iterator(end());//把正向迭代器传输过去
}
reverse_iterator rend()
{
return reverse_iterator(begin());//把正向迭代器传输过去
}
//构造函数
list()
{
init();
}
void init()
{
_head = new Node;//创建带头节点
_head->_next = _head;//构成双向循序
_head->_prev = _head;
}
//尾插
void push_back(const T& x)
{
insert(end(), x);
先创建新节点
//Node* newnode = new Node(x);
先找到尾节点
//Node* tail = _head->_prev;
开始链接
//tail->_next = newnode;
//newnode->_prev = tail;
//newnode->_next = _head;
//_head->_prev = newnode;
}
//指向第一个有效节点
iterator begin()
{ //单参数隐式类型转换
//return iterator(_head->_next);
return _head->_next;
}
const_iterator begin()const
{ //单参数隐式类型转换
//return iterator(_head->_next);
return _head->_next;
}
//指向头节点：哨兵位
iterator end()
{
//return iterator(_head);
return _head;
}
//指向头节点：哨兵位
const_iterator end()const
{
//return iterator(_head);
return _head;
}
//插入
iterator insert(iterator pos,const T& x)
{
//创建插入节点
Node* newnode = new Node(x);
//记录插入位置
Node* node = pos._node;
Node* nodeprev = node->_prev;
nodeprev->_next = newnode;
newnode->_prev = nodeprev;
newnode->_next = node;
node->_prev = newnode;
//return iterator(newnode);
return newnode;
}
//头插
void push_front(const T& x)
{
insert(begin(), x);
}
//erase 删除
iterator erase(iterator pos)
{
//记录位置
Node* node = pos._node;
Node* nodenext = node->_next;
Node* nodeprev = node->_prev;
//开始链接
nodeprev->_next = nodenext;
nodenext->_prev = nodeprev;
delete node;
return nodenext;
}
//pop_back 尾删
void pop_back()
{
erase(--end());
}
//pop_front 头删
void pop_front()
{
erase(begin());
}
//clear 清理
void clear()
{
iterator it = begin();
while (it != end())
{
it = erase(it);
//erase(it);
}
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
//list l2(l1) 拷贝构造
list(list<T>& lt)
{
init();
for (const auto& e : lt)
{
push_back(e);
}
}
//赋值拷贝 传统写法
/*list<T>& operator=(list<T>& lt)
{
if (*this != lt)
{
clear();
for (const auto& e : lt)
{
push_back(e);
}
}
return *this;
}*/
void swap(list<T>& tmp)
{
std::swap(_head, tmp._head);
}
//赋值拷贝 现代写法
list<T>& operator=(list<T> lt)
{
swap(lt);
return *this;
}
private:
Node* _head;//带头节点：哨兵位
};
void test2()
{
lj::list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lj::list<int>::reverse_iterator rit = lt.rbegin();
while (rit != lt.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
}
}
//vector.h
#pragma once
#include <assert.h>
#include"ReverseIterator.h"
namespace lj
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef const T* const_iterator;
typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;
//迭代器构造
template <class Inputiterator>
vector(Inputiterator first, Inputiterator last)
{
while (first != last)
{
push_back(*first);
first++;
}
}
reverse_iterator rbegin()
{
return reverse_iterator(end());//把正向迭代器传输过去
}
reverse_iterator rend()
{
return reverse_iterator(begin());//把正向迭代器传输过去
}
//构造函数
vector()
{
_start = nullptr;
_finish = nullptr;
_endofstorage = nullptr;
}
//拷贝构造 现代写法 v2(v1)
vector(const vector<T>& v)
{
reserve(v.capacity());
for (auto e : v)
{
push_back(e);
}
}
T& operator[](size_t pos)
{
assert(pos < size());
return _start[pos];
}
void swap(vector<T>& v)
{
std::swap(_start,v._start);
std::swap(_finish, v._finish);
std::swap(_endofstorage, v._endofstorage);
}
vector<T>& operator=(vector<T> v)
{
swap(v);
return *this;
}
//析构函数
~vector()
{
if(_start)
delete[] _start;
_start = nullptr;
_finish = nullptr;
_endofstorage = nullptr;
}
size_t capacity()const
{
return _endofstorage - _start;
}
size_t size()const
{
return _finish - _start;
}
iterator begin()
{
return _start;
}
const_iterator begin()const
{
return _start;
}
iterator end()
{
return _finish;
}
const_iterator end()const
{
return _finish;
}
void reserve(size_t n)
{
if (n>capacity())
{
size_t old = size();//记录原空间的大小
T* tmp = new T[n];//开辟新空间——异地扩容
if (_start)
{
for (size_t i = 0; i < old; i++)
{
tmp[i] = _start[i];//赋值拷贝为深拷贝
}
delete[] _start;//释放原空间
}
_start = tmp;//指向新空间
_finish = _start + old;
_endofstorage = _start + n;
}
}
//尾插函数
void push_back(const T& x)
{
//检查扩容
if (_finish == _endofstorage)
{
size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newcapacity);
}
*_finish = x;
_finish++;
}
//插入函数
iterator insert(iterator pos, const T& x)
{
assert(pos <= _finish && pos >= _start);
//检查扩容
if (_finish == _endofstorage)
{
size_t len = pos - _start;//记录原空间长度
reserve(capacity() == 0 ? 4 : capacity() * 2);
pos = len + _start;//让pos指向新空间并且同步长度
}
//开始利用函数插入,往后挪动数据
//memmove(pos + 1, pos, (_finish - pos) * sizeof(T));
iterator end = _finish - 1;
while (end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = x;
_finish++;
return pos;
}
//resize 扩容初始化
void resize(size_t n, const T& val = T())
{
if (n > size())
{
reserve(n);//扩容
while (_finish < _start + n)
{
*_finish = val;
_finish++;
}
}
else
{
_finish = _start + n;
}
}
//erase 删除
iterator erase(iterator pos)
{
assert(pos <= _finish && pos >= _start);
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 test_vector()
{
vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
lj::vector<int>::reverse_iterator rit = v.rbegin();
while (rit != v.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
}
}
//test.cpp
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<list>
#include<vector>
using namespace std;
#include"List.h"
#include"vector.h"
int main()
{
//lj::test2();
lj::test_vector();
return 0;
/*lj::list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lj::list<int>::reverse_iterator rit = lt.rbegin();
while (rit != lt.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
return 0;*/
}
扫一扫
752
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
