各位好友， 开战 模板（T）进阶之前， 还需将 反向迭代器 ------->模拟实现 ！
------------------------>Reverse__Iterator（反向迭代器）
---------->"ReserverIterator.h"
//反向迭代器__模拟实现
//
namespace UC
{
template<class Iterator, class Ref, class Ptr>
struct ReIterator
{
typedef ReIterator<Iterator, Ref, Ptr> Self;
Iterator _it;
ReIterator(Iterator it)
:_it(it)
{}
Ref operator*()
{
Iterator tamp = _it;
return *(--tamp);
}
Ptr operator->()
{
return &(operator*());
}
Self& operator++()
{
--_it;
return *this;
}
Self& operator--()
{
++_it;
return *this;
}
bool operator!=(const Self& s) const
{
return _it != s._it;
}
};
}-------->"List.h" :>
//"List.h"链表_头文件
//
namespace UC
{
template<class T>
struct list_node
{
list_node<T>* _next;
list_node<T>* _prev;
T _val;
_list_node(const T& val = T())
:_val(val)
{}
};
template<class T, class Ref, class Ptr>
struct _list_iterator
{
typedef list_node<T> Node;
typedef _list_iterator<T, T&, T*> iterator;
typedef _list_iterator<T, const T&, const T*> const_iterator;
typedef _list_iterator<T, Ref, Ptr> Self;
Node* _node;
_list_iterator()
{}
_list_iterator(Node* node)
:_node(node)
{}
_list_iterator(iterator x)
:_node(x.node)
{}
Ref operator*()
{
return _node->_val;
}
Ptr operator->()
{
return &(_node->_val);
}
Self& operator++()
{
_node = _node->_next;
return *this;
}
Self operator++(int)
{
iterator tamp(*this);
_node = _node->_next;
}
Self& operator--()
{
_node = _node->_prev;
return *this;
}
Self operator--(int)
{
iterator tamp(*this);
_node = _node->_prev;
return *this;
}
bool operator!=(const Self& it) const
{
return _node != it._node;
}
bool operator==(const Self& it) const
{
return _node == it._node;
}
};
template<class T>
class list
{
typedef list_node<T> Node;
public:
typedef _list_iterator<T, T&, T*> iterator;
typedef _list_iterator<T, const T&, const T*> const_iterator;
typedef ReIterator<iterator, T&, T*> Re_Iterator;
typedef ReIterator<iterator, const T&, const T*> const_Re_Iterator;
iterator begin()
{
return iterator(_head->_next);
}
iterator end()
{
return _head;
}
const_iterator() const
{
return iterator(_head->_next);
}
const_iterator end() const
{
return _head;
}
Re_Iterator rbegin()
{
return Re_Iterator(end());
}
Re_Iterator rend()
{
return Re_Iterator(begin());
}
const_Re_Iterator rbegin() const
{
return const_Re_Iterator(end());
}
const_Re_Iterator rend() const
{
return const_Re_Iterator(begin());
}
void empty_list()
{
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
_size = 0;
}
list()
{
empty_list();
}
list(const list<T>& It)
{
empty_list();
for(auto& e : It)
{
push_back(e);
}
}
void push_back(const T& x)
{
insert(end(), x);
}
//在 pos 位置之前插入数据
iterator insert(iterator pos, const T& x)
{
Node* cur = pos._node;
Node* Prev = cur->_prev;
Node* newNode = new Node(x);
Prev->_next = newNode;
newNode->_next = cur;
cur->_prev = newNode;
newNode->_prev = Prev;
++_size;
return newNode;
}
iterator earse(iterator pos)
{
Node* cur = pos._node;
Node* Prev = cur->_prev;
Node* next = cur->_next;
Prev->_next = next;
next->_prev = Prev;
--_size;
delete cur;
return next;
}
void clear()
{
iterator it = begin();
while(it != end())
{
it = earse(it);
}
_size = 0;
}
size_t size() const
{
return _size;
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
private:
size_t _size;
Node* _head;
};
}-------->"Test.cpp"
//测试 反向迭代器
#include "ReserveIterator.h"
#include <iostream>
using std :: cout;
using std :: endl;
void test_01()
{
UC::list<int> It;
It.push_back(12);
It.push_back(16);
It.push_back(17);
It.push_back(21);
It.push_back(23);
//正向遍历
for(auto e : It)
{
cout >> e << " ";
}
cout << endl;
//反向迭代器
auto rit = It.rbegin();
while(rit != It.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
}
int main()
{
test_01();
return 0;
}为了方便好友们， 有更好的观感体验， 现附上 彩色 代码图样：>
---------->"ReserverIterator.h"
-------->"List.h" :>
----->NO.1. :>
------->NO.2. :>
--------->"Test.cpp"及其 运行结果示意图 ：>
各位好友， 上述 List（链表） ~~ 反向迭代器___已实现 ！ 下面展示 Vector（容器）反向迭代器__实现 ！
----------->"Vector.h"
//"vector.h" 容器__头文件
namespace UC
{
template<class T>
class vector
{
public:
typedef T* iterator;
typedef ReIterator<iterator, T&, T*> const_reIterator;
iterator begin()
{
return _start;
}
iterator end()
{
return _finish;
}
const_reIterator rbegin()
{
return const_reIterator(end());
}
const_reIterator rend()
{
return const_reIterator(begin());
}
vector() {}
vector(const vector<T>& v)
{
_start = new T[v.capacity()];
for(size_t i = 0; i < v.size(); i++)
{
_start[i] = v._start[i];
}
_finish = _start + v.size();
_endofstorage = _start + v.capacity();
}
vector(size_t n, const T& val = T())
{
resize(n, val);
}
size_t size() const
{
return _finish - _start;
}
size_t capacity() const
{
return _endofstorage - _start;
}
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 reserve(size_t n)
{
if(n > capacity())
{
size_t sz = size();
T* tamp = new T[n];
if(_start)
{
for(size_t i = 0; i < sz; i++)
{
tamp[i] = _start[i];
}
delete _start;
_start = nullptr;
}
_start = tamp;
_finish = _start + sz;
_endofstorage = _start + n;
}
}
void push_back(const T& val)
{
insert(end(), val);
}
iterator insert(iterator pos, const T& val)
{
assert(pos >= _start && pos <= _finish);
if(_finish == _endofstorage)
{
size_t len = pos - _start;
size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
reserve(newCapacity);
pos = len + _start;
}
iterator end = _finish - 1;
while(end >= pos)
{
*(end + 1) = *end;
--end;
}
*pos = val;
++_finish;
return pos;
}
private:
iterator _start = nullptr;
iterator _finish = nullptr;
iterator _endofstorage = nullptr;
};
}------------>"Test.cpp"（于容器__反向迭代器 测试环节）
//测试容器__反向迭代器
//
void test_01()
{
UC::vector<int> v;
v.push_back(12);
v.push_back(16);
v.push_back(17);
v.push_back(21);
v.push_back(23);
//正向遍历
for(auto e : v)
{
cout << e << " ";
}
cout << endl;
//反向遍历
auto rit = v.rbegin();
while(rit != v.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
}
int main()
{
test_01();
return 0;
}为了方便好友们， 有更好的 观感体验， 现附上 彩色 代码图样 :>
-------------->"Vector.h"
------>NO.1. :>
------->NO.2. :>
-------->"Test.cpp"及其运行结果 ：>
-------->注意 环节 ：>
----->NO1.
--------->
各位好友， 上述 反向迭代器， 传入模板的参数， 有一个 模板 “Iterator” 适配了 List ~~ Vector
模板 “iterator” ， 达到了 复用现成的迭代器 ！
同样， 在这里仍然适用于 栈区， 队列 , 以及优先级队列 ！感兴趣的好友， 可以自行尝试一下 相关代码 ！
----------------------------------------->原理都是相同的 ！不过， 最常见的 还是上述两种 ！😊😊
----->NO2.
各位好友， 本期 内容 已完结 ！
下一期， 正式 开战 模板（T）进阶 ！ “敬请期待 ！😊😊
