C++——实现一个简单的迭代器
迭代器
- 1、迭代器的原理
- 2、迭代器的实现
- 3、容器查找
- 4、容器排序
- 总代码
1、迭代器的原理
为了提高C++编程的效率，STL中提供了许多容器，包括vector、list、map等。为了统一访问方式，STL为每种容器在实现的时候设计了一个内嵌的iterator类，不同的容器有自己专属的迭代器，使用迭代器来访问容器中的数据。迭代器对一些基本操作如*、–、++、==、!=进行了重载，使其具有了遍历复杂数据结构的能力，其遍历机制取决于所遍历的容器，迭代器的使用和指针的使用非常相似。通过begin，end函数获取容器的头部和尾部迭代器，当begin和end返回的迭代器相同时表示容器为空。简单来说，迭代器就是一个遍历的过程，像使用指针一样使用迭代器就可以访问这个容器。
- 迭代器就是一个类的对象，通过对这个类对象进行操作（如：++, --等）可以实现对容器的遍历，这样用户便可以不用关心它的实现。
- 如上图所示：迭代器有三成员，但都是指针，并且一个容器里面会存在两个迭代器，一个是起始迭代器(begin)，一个是终止迭代器(end)。
- 起始迭代器：起始指针始终指向起始位置，终止指针始终指向容器最后一个位置,现在指针（可能叫法不太严谨）可以指向容器中的任意位置，但可以通过重载运算符(++,–)来操作现在指针指向的位置。
- 终止迭代器：起始指针和终止指针是一样的，现在指针不一样，现在指针始终是指向终止指针的后面一个（也就是null），一直指向null。
2、迭代器的实现
定义一个迭代类所需要的操作：
这里我们使用一下之前我写过的一个链表容器来辅助实现：
class iterator//迭代类
{
private:
node* m_start;//起始指向
node* m_cur;//现在指向
node* m_end;//中止指向
public:
iterator(node* start, node* cur, node* end): m_start(start), m_cur(cur), m_end(end){}
T& operator*() {//重载*运算符
if (m_cur == nullptr)
throw underflow_error("链表为空。");//抛出异常
else
return m_cur->m_data;
}
//重载++运算符
iterator& operator++() {
if (m_cur == nullptr)
m_cur = m_start;
else
m_cur = m_cur->m_next;
return *this;
}
//重载--运算符
iterator& operator--() {
if (m_cur == nullptr)
m_cur = m_tail;
else
m_cur = m_cur->pre;
return *this;
}
//重载==运算符
bool operator==(const iterator& that)const {
return m_start == that.m_start && m_cur == that.m_cur && m_end == that.m_end;
}
//重载!=运算符
bool operator!=(const iterator & that)const {
return !(*this == that);
}
friend class list;
};
这个迭代类是定义在链表容器类里面的成员类，下面总代码中就知道了。
- 我们做了迭代类的实现，但我们还要实现一下迭代器的对象，我们需要在链表类里面定义一个函数用来实现迭代类的对象，也就是迭代器，我们分别定义begin和end两个迭代器。
//创建迭代器
iterator begin() {
return iterator(m_head, m_head, m_tail);
}
//创建第二个迭代器
iterator end() {
return iterator(m_head, nullptr, m_tail);
}
这样我们只要创建一个容器的对象来调用这两个函数就产生两个迭代器了，然后用迭代类里面的重载运算符就可以使用迭代器遍历容器了。
3、容器查找
查找很简单，遍历判断就行了：
template<class IT, class TD>
IT find(const IT &begin, const IT &end, const TD& number)
{
for (IT it = begin; it != end; ++it)
{
if (*it == number)
return it;
}
return end;
}
4、容器排序
我们要为一个容器写一个排序函数对容器进行排序。
我们采用快速排序的方式，那我们先来讲一下什么是快速排序：
排序（"<"）
template<class IT>
void sort(const IT& begin, const IT& end)
{
IT p = begin;
IT last = end;
--last;
for (IT i = begin, j = last; i != j;)
{
while (i != p && *i < *p)//两个变量不相等并且i
++i;
if (i != p)
{
swap(*i, *p);
p = i;
}
while (j != p && *p < *j)
--j;
if (j != p)
{
swap(*p, *j);
p = j;
}
}
IT be = begin;
++be;
if (p != begin && p != be)
sort(begin, p);//递归左边
be = p;
++be;
if (be != end && be!= last)
sort(be, end);//递归右边
}
代码可能有点烂，但能力之内了，请见谅。
但我们这样的话就只能升序了，而如果想要降序的话就还需要重新写一个函数，这样的话就非常麻烦，所以我们可以实现一个比较器来配合着上面这个代码，就相当于进行了一个优化。
比较器：简单来说就是一个类，制造容器的人不负责制造比较器这个类，需要用户自己来定义一个这样的类。
//一个简单的比较器
lass MSD
{
public:
bool operator()(int a, int b) {
return a > b;//可以是大于或小于
}
};
//排序(比较器)
template<class IT, class MSD>//MSD是一个类
void sort(const IT& begin, const IT& end, MSD msd)
{
IT p = begin;
IT last = end;
--last;
for (IT i = begin, j = last; i != j;)
{
while (i != p && msd(*i, *j))
++i;
if (i != p)
{
swap(*i, *p);
p = i;
}
while (j != p && msd(*p, *j))
--j;
if (j != p)
{
swap(*p, *j);
p = j;
}
}
IT be = begin;
++be;
if (p != begin && p != be)
sort(begin, p, msd);
be = p;
++be;
if (be != end && be != last)
sort(be, end, msd);
}
总代码
#include可能说的有点不好，但需要你学习关于链表的知识才能搞清楚这个知识。