个人主页:Lei宝啊
愿所有美好如期而遇
迭代器理解:
string和vector容器,他们底层的物理空间是连续的,所以他们的迭代器可以使用原生指针,char*,模板T*,但是list,map等容器,他们底层的物理空间不是连续的,所以他们的迭代器也就不能使用原生指针,我们平时是怎么使用迭代器呢?list<T>::iterator it; it++; it++是怎么到达下一个链表节点的呢?
我们可以想想iterator是什么类型,自定义类型可以进行运算符重载,也就是说it++是进行了运算符重载才能实现的,但是我们去哪里进行运算符重载,list里实现运算符重载?那就是list的++重载,所以我们需要定义一个iterator类,在他自己的类里进行++运算符重载,然后将他的类名在list类里typedef为iterator,这样,list就可以使用iterator了,list里的begin(),end()方法,返回值是iterator,也就是说在返回时构造一个iterator对象。
我们还可以发现一个问题,所有容器的迭代器都叫做iterator,每个容器的迭代器都是不同的,但是为了保证使用的统一性,在容器的内部统一将迭代器类重命名为iterator。
迭代器不只有iterator,还有反向迭代器,reverse_iterator,我们理解了上面的内容后,这个就很简单,再写出他们的迭代器类,再在容器类里面重命名为iterator_reverse不就行了,这样虽然是可行的,但是代码重复性太高,那么库里是怎么实现的呢?库里使用了适配器,只写了一个reverse_iterator类,模板参数加上class iterator,只要得到你的正向迭代器,那么我就能适配出反向迭代器,并且不管是哪个容器,都能适配出来。
迭代器模拟实现:
实现迭代器,我们还要模拟实现容器,vector,list都可以,我们这里以list为例,先模拟实现list:
template<class T>
struct ListNode
{
ListNode<T>* next;
ListNode<T>* prev;
T data;
ListNode(const T& x = T())
:next(nullptr)
,prev(nullptr)
,data(x)
{}
};
template<class T>
class list
{
typedef ListNode<T> Node;
public:
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
typedef Reverse_iterator<iterator, T&, T*> reverse_iterator;
typedef Reverse_iterator<const_iterator, const T&,const T*> const_reverse_iterator;
void empty_init()
{
_head = new Node();
_head->prev = _head;
_head->next = _head;
}
//构造函数
//list<int> lt(); < this
//
list<T>()
{
empty_init();
}
list(int n, const T& value = T())
{
empty_init();
for (int i = 0; i < n; i++)
{
push_back(value);
}
}
template <class Iterator>
list(Iterator first, Iterator last)
{
empty_init();
while (first != last)
{
push_back(*first);
first++;
}
}
void swap(list<T>& x)
{
std::swap(_head, x._head);
}
//拷贝构造
list(list<T>& copy)
{
empty_init();
iterator it = copy.begin();
while (it != copy.end())
{
push_back(it._node->data);
it++;
}
}
list<T>& operator=(list<T> tmp)
{
swap(tmp);
return *this;
}
void push_back(const T& x = T())
{
//_head->prev newnode _head
//Node* newnode = new Node(x);
//Node* tail = _head->prev;
//
//tail->next = newnode;
//newnode->prev = tail;
//_head->prev = newnode;
//newnode->next = _head;
insert(end(), x);
}
void push_front(const T& val)
{
insert(begin(), val);
}
iterator insert(iterator pos, const T& x = T())
{
//pos->prev newnode pos
Node* cur = pos._node;
Node* prev = cur->prev;
//prev newnode cur
Node* newnode = new Node(x);
newnode->next = cur;
cur->prev = newnode;
prev->next = newnode;
newnode->prev = prev;
return newnode;
}
reverse_iterator rbegin()
{
return end();
}
reverse_iterator rend()
{
return begin();
}
const_reverse_iterator rbegin()const
{
return end();
}
const_reverse_iterator rend()const
{
return begin();
}
iterator begin()
{
return iterator(_head->next);
}
const_iterator begin() const
{
return _head->next;
}
iterator end()
{
return iterator(_head);
}
const_iterator end() const
{
return _head;
}
iterator erase(iterator pos)
{
Node* cur = pos._node;
Node* prev = cur->prev;
Node* next = cur->next;
prev->next = next;
next->prev = prev;
return iterator(next);
}
void pop_back()
{
erase(--end());
}
void pop_front()
{
erase(begin());
}
size_t size()const
{
int num = 0;
Node* cur = _head->next;
while (cur != _head)
{
num++;
cur = cur->next;
}
return num;
}
bool empty()const
{
return _head->next == _head;
}
T& front()
{
return _head->next->data;
}
const T& front()const
{
return _head->next->data;
}
T& back()
{
return _head->prev->data;
}
const T& back()const
{
return _head->prev->data;
}
void clear()
{
iterator it= begin();
while (it != end())
{
erase(it++);
}
}
~list()
{
clear();
delete _head;
_head = nullptr;
}
private:
Node* _head;
};
接下来就是迭代器:
template<class T, class ref, class ptr>
struct __list_iterator
{
typedef ListNode<T> Node;
public:
//构造函数
__list_iterator(Node* node = nullptr)
:_node(node)
{}
__list_iterator(const __list_iterator& self)
:_node(self._node)
{}
//前置++
__list_iterator& operator++()
{
_node = _node->next;
return *this;
}
//后置++
__list_iterator& operator++(int)
{
//auto tmp = __list_iterator(this->_node);
auto tmp = __list_iterator(*this);
_node = _node->next;
return tmp;
}
//前置--
__list_iterator& operator--()
{
_node = _node->prev;
return *this;
}
//后置--
__list_iterator& operator--(int)
{
//auto tmp = __list_iterator(this->_node);
auto tmp = __list_iterator(*this);
_node = _node->prev;
return tmp;
}
ref operator*()
{
return _node->data;
}
ptr operator->()
{
return &_node->data;
}
bool operator!=(const __list_iterator& x)
{
return _node != x._node;
}
bool operator==(const __list_iterator& x)
{
return _node == x._node;
}
Node* _node;
};
最后就是适配器:
// 将以下代码适配到vector和list中做反向迭代器,理解反向迭代器的原理
// 适配器 -- 复用
template<class iterator, class Ref, class Ptr>
struct Reverse_iterator
{
//构造函数
Reverse_iterator(iterator it)
:_it(--it)
{}
Reverse_iterator& operator++()
{
_it--;
return *this;
}
//后置++
Reverse_iterator& operator++(int)
{
//auto tmp = __list_iterator(this->_node);
auto tmp = Reverse_iterator(*this);
_it--;
return tmp;
}
bool operator!=(const Reverse_iterator& x)
{
return _it != x._it;
}
Ref operator*()
{
return *_it;
}
iterator _it;
};
// vector和list反向迭代器实现