STL模拟实现迭代器

最新推荐文章于 2022-08-31 11:40:02 发布
最新推荐文章于 2022-08-31 11:40:02 发布
阅读量214 收藏
点赞数
分类专栏： c++ 文章标签： stl 迭代器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lx8211667846947/article/details/78444875
版权

迭代器(iterator)是一中检查容器内元素并遍历元素的数据类型。
用于提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示，也可以这么说：Iterator模式是运用于聚合对象的一种模式，通过运用该模式，使得我们可以在不知道对象内部表示的情况下，按照一定顺序（由iterator提供的方法）访问聚合对象中的各个元素。
一般仅用于底层聚合支持类，如STL的list、vector、stack等容器类及ostream_iterator等扩展iterator。

一、模拟实现Vector

//完成标准容器Vector
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
#include<string>
//#include"Vector.h"
using namespace std;
//为了提高效率，在此进行类型萃取，将自定义类型与内置类型分开处理
//自定义类型用memcpy会出错，故只能用for循环进行赋值和拷贝
//而如果全部用for循环的话，如果是内置类型，则效率太低，故将其分开
struct TypeFalse
{
    static bool IsPODType()
    {
        return false;
    }
};
struct TypeTrue
{
    static bool IsPODType()
    {
        return true;
    }
};
template <class T>
struct TypeTail
{
    typedef TypeFalse PODType;
};
template<>
struct TypeTail<int>
{
    typedef TypeTrue PODType;
};
template<>
struct TypeTail<char>
{
    typedef TypeTrue PODType;
};

template<>
struct TypeTail<float>
{
    typedef TypeTrue PODType;
};

template<>
struct TypeTail<double>
{
    typedef TypeTrue PODType;
};


template <class T>
struct Vector
{
public:
    typedef T* Iterator;
    typedef const T* ConstIterator;
public:
    Vector()
        : _start(0)
        , _finish(0)
        , _endOfStorage(0)
    {}

    Vector(const T* array, size_t size)
        :_start(new T[size])
        , _finish(_start)
        , _endOfStorage(_start + size)
    {
        if (TypeTail<T>::PODType::IsPODType())
        {
            memcpy(_start, array, sizeof(T)*size);
            _finish = _start + size;
        }
        else
        {
            for (size_t i = 0; i < size; i++)
            {
                *_finish++ = array[i];
            }
        }
    }
    Vector(const Vector<T>& v)
    {
        _start = new T[size];
        if (TypeTail<T>::PODType::IsPODType())
            memcpy(_start, v._start, sizeof(T)*v.Size());
        else
        {
            for (size_t i = 0; i < size; i++)
            {
                _start[i] = v._start[i];
            }
        }
        _finish = _start + size;
        _endOfStorage + size;
    }
    //Vector& operator=(const Vector<T>& s)
    Vector& operator=(const Vector<T>& s)
    {
        if (this != &s)
        {
            _start = new T[1];
            Vector temp(s);
            swap(temp._start, _start);
        }
        return *this;
    }
    ~Vector()
    {
        if (_start)
            delete[] _start;
        _start = _finish = _endOfStorage = 0;
    }

    //////////////Iterator///////////////////////////////// 
    Iterator Begin()
    {
        return _start;
    }
    Iterator End()
    {
        return _finish;
    }
    ConstIterator Begin()const
    {
        return _start;
    }
    ConstIterator End()const
    {
        return _finish;
    }
    void PushBack(const T& data)
    {
        _CheckCapacity();
        *_finish = data;
        ++_finish;
    }
    void PopBack()
    {
        assert(!Empty());
        --_finish;
    }
    void Insert(size_t pos, const T& data)
    {
        _CheckCapacity();
        size_t size = Size();
        assert(pos >= 0 && pos <= size);
        for (size_t i = size; i > pos; i--)
        {
            _start[i] = _start[i - 1];
        }
        _start[pos] = data;
        ++_finish;
    }
    void Erase(size_t pos)
    {
        size_t size = Size();
        assert(pos >= 0 && pos < size);
        for (size_t i = pos; i < size - 1; ++i)
        {
            _start[i] = _start[i + 1];
        }
        --_finish;
    }

    //////////////////capacity//////////////////////////// 
    size_t Size()const
    {
        return _finish - _start;
    }
    size_t Capacity()const
    {
        return _endOfStorage - _start;
    }
    bool Empty()const
    {
        return _start == _finish;
    }
    void Resize(size_t newSize, const T& data = T())
    {
        size_t size = Size();
        size_t capacity = Capacity();
        if (newSize < size)
        {
            _finish = _start + newSize;
        }
        else if (size < newSize&&newSize < capacity)
        {
            for (size_t i = 0; i < newSize; ++i)
            {
                *_finish++ = data;
            }
            _finish = _start + newSize;
        }
        else//大于容量，需要增容
        {

            T* temp = new T[newSize];
            if (TypeTail<T>::PODType::IsPODType())
                memcpy(temp, _start,size*sizeof(T));
            else
            {
                for (size_t i = 0; i < size; i++)
                {
                    temp[i] = _start[i];
                }
            }
            for (size_t i = size; i < newSize; i++)
            {
                temp[i] = data;
            }
            delete[] _start;
            _start = temp;
            _finish = _start + newSize;
            _endOfStorage = _start + newSize;
        }
    }

    //////////////Acess/////////////////////////// 
    T& operator[](size_t index)
    {
        assert(index < Size() && index >= 0);
        return _start[index];
    }
    const T& operator[](size_t index)const
    {
        assert(index < Size() && index >= 0);
        return _start[index];
    }
    T& Front()
    {
        return *_start;
    }
    const T& Front()const
    {
        return *_start;
    }
    T& Back()
    {
        return *(_finish - 1);
    }
    const T& Back()const
    {
        return *(_finish - 1);
    }
    void Clear()
    {
        _finish = _start;
    }

    //template<class T>
    friend ostream& operator<<(ostream& _cout, const Vector<T>& v)
    {
        Vector<T>::ConstIterator t1 = v.Begin();
        while (t1 != v.End())
        {
            _cout << *t1 << " ";
            ++t1;
        }
        return _cout;
    }

private:
    void _CheckCapacity()
    {
        size_t capa = Capacity();
        size_t size = Size();
        if (size >= capa)
        {
            size_t capacity = capa ? capa * 2 : 3;
            T* temp = new T[capacity];
            if (TypeTail<T>::PODType::IsPODType())
                memcpy(temp, _start, size*sizeof(T));
            else
            {
                for (size_t i = 0; i < size; i++)
                {
                    temp[i] = _start[i];
                }
            }
            assert(temp);
            delete[] _start;
            _start = temp;
            _finish = _start + size;
            _endOfStorage = _start + capacity;
        }
    }

private:
    T* _start;
    T* _finish;
    T* _endOfStorage;
};
//测试代码：
void TestVector()
{
    int arr[] = { 1, 2, 3, 4 };

    Vector<int>v1(arr, 4);
    cout << v1 << endl;
    v1.Insert(0, 0);
    v1.Insert(v1.Size(), 5);
    v1.Insert(4, -4);
    cout << v1 << endl;

    v1.Erase(4);
    v1.Erase(0);
    v1.Erase(v1.Size() - 1);

    v1.PopBack();
    cout << v1 << endl;
    v1.PopBack();
    v1.PopBack();
    v1.PopBack();
    cout << v1 << endl;

    v1.PushBack(1);
    v1.PushBack(2);
    v1.PushBack(3);
    v1.PushBack(4);
    cout << v1 << endl;

    v1.Resize(10, 5);
    cout << v1 << endl;

    v1.Resize(30);
    cout << v1 << endl;

    v1.Resize(3);
    cout << v1 << endl;
}
void Teststring()
{
    string arr[4] = { string("111"), string("2222"),
        string("3333"), string("4444") };
    Vector<string>v1(arr, 4);
    cout << v1 << endl;
    v1.Insert(0, string("0000"));
    v1.Insert(v1.Size(), string("5555"));
    cout << v1 << endl;
    v1.Resize(20, string("1234"));
    cout << v1 << endl;
}
int main()
{
    cout << "TestVector:" << endl << endl;
    TestVector();

    cout << endl << endl;
    cout << "Teststring:" << endl << endl;
    Teststring();

    getchar();
    return 0;
}

运行结果：

二、模拟实现List

#include<iostream>
#include<assert.h>
using namespace std;

//完成标准容器List
//对于结点的封装
template<class T>
struct ListNode
{
    ListNode(const T& data = T())
    : _pPre(0)
    , _pNext(0)
    , _data(data)
    {}

    ListNode* _pPre;
    ListNode* _pNext;
    T _data;
};
//迭代器
//实现指针的功能，比如++，--，解引用 ……
template<class T,class Ref,class Ptr>
class ListIterator
{
    typedef ListNode<T> Node;
    typedef ListIterator Self;
public:
    Self()
        : _pCur(0)
    {}

    Self(Node* pCur)
        : _pCur(pCur)
    {}

    Self(const Self& s)
        : _pCur(s._pCur)
    {}

    T operator*()
    {
        return _pCur->_data;
    }

    Ptr operator->()
    {
        return &(operator*());
        //return &(_pCur->_data); 
    }

    Self& operator++()
    {
        _pCur = _pCur->_pNext;
        return*this;
    }

    Self operator++(int)
    {
        Self temp(*this);
        _pCur = _pCur->_pNext;
        return temp;
    }

    Self& operator--()
    {
        _pCur = _pCur->_pPre;
        return*this;
    }

    Self operator--(int)
    {
        Self temp(*this);
        _pCur = _pCur->_pPre;
        return temp;
    }

    bool operator!=(const Self& s)
    {
        return _pCur != s._pCur;
    }

    bool operator==(const Self& s)
    {
        return _pCur == s._pCur;
    }

    Node* _pCur;
};


//List:
template<class T>
class List
{
public:
    typedef ListNode<T> Node;
    typedef ListIterator<T, T*, T&> Iterator;
    //typedef ListIterator<T, const T*, const T&> ConstIterator;
public:
    List()
        : _pHead(new Node)
    {
        _pHead->_pNext = _pHead;
        _pHead->_pPre = _pHead;
    }

    // 1 2 3 4 5 
    List(const T* array, size_t size)
    {
        if (_pHead == NULL)
        {
            _pHead = new Node;
            _pHead->_pNext = _pHead;
            _pHead->_pPre = _pHead;
        }
        for (size_t i = 0; i < size; i++)
        {
            PushBack(array[i]);
        }
    }
    List(/*const*/ List& l)
    {
        size_t size = l.Size();
        Node* temp =l._pHead->_pNext;
        _pHead = new Node;
        _pHead->_pNext = _pHead;
        _pHead->_pPre = _pHead;
        while (size--)
        {
            PushBack(temp->_data);
            temp = temp->_pNext;
        }
    }
    List& operator=(const List& l)
    {
        if (&l == this)
            return *this;
        List temp(l);
        swap(l._pHead, _pHead);
    }
    ~List()
    {
        Clear();
        if (_pHead)
            delete _pHead;
        _pHead = 0;
    }

        ///////////////////////////////////////////////////// 
    Iterator Begin()
    //ConstIterator Begin()const
    {
        //return Iterator(_pHead->_pNext);
        return _pHead->_pNext;
    }

    //ConstIterator End()const
    Iterator End()
    {
        //return Iterator(_pHead);
        return _pHead;
    }
    /////////////////////Modify////////////////////////// 
    void PushBack(const T& data)
    {
        Insert(End(), data);
    }
    void PopBack()
    {
        Erase(Iterator(_pHead->_pPre));

    }
    void PushFront(const T& data)
    {
        Insert(Begin(), data);
    }
    void PopFront()
    {
        Erase(Begin());
    }
    Iterator Insert(Iterator pos, const T& data)
    {
        Node* Pos = pos._pCur;
        Node* NewNode = new Node(data);

        NewNode->_pNext = Pos;
        NewNode->_pPre = Pos->_pPre;
        Pos->_pPre->_pNext = NewNode;
        Pos->_pPre = NewNode;
        //return Iterator(NewNode);
        return NewNode;
    }
    Iterator Erase(Iterator pos)
    {
        Iterator it = Begin();
        while (it != End())
        {
            if (*it == *pos)
            {
                Node* temp = pos._pCur;
                temp->_pPre->_pNext  = temp->_pNext;
                temp->_pNext->_pPre = temp->_pPre;
                pos = temp->_pPre;
                return Iterator(pos);
            }
            ++it;
        }
        return End();
    }
    bool Empty()const
    {
        return _pHead->_pNext == _pHead;
    }
    template<class T>
    Iterator Find(const T&data)
    {
        List<T>::Iterator it = Begin();
        while (it != End())
        {
            if (*it == data)
                return it;
            ++it;
        }
    }
    size_t Size()/*const*/
    {
        size_t count = 0;
        /*Const*/Iterator it = Begin();
        while (it != End())
        {
            ++count;
            ++it;
        }
        return count;
    }
    T& Front()
    {
        return _pHead->_pNext->_data;
    }
    const T& Front()const
    {
        return _pHead->_pNext->_data;
    }
    T& Back()
    {
        return _pHead->_pPre->_data;
    }
    const T& Back()const
    {
        return _pHead->_pPre->_data;
    }
    void Clear()
    {
        Node* temp = _pHead->_pNext;
        while (temp != _pHead)
        {
            PopBack();
        }
    }
    friend ostream&operator<<(ostream&_cout, /*const*/ List<T>&l)
    {
        List<T>::/*Const*/Iterator it = l.Begin();
        while (it != l.End())
        {
            _cout << *it << "->";
            ++it;
        }
        cout << "->NULL" << endl;
        return _cout;
    }
private:
    ListNode<T>* _pHead;
};
//测试代码：
void TestList1()
{
    int array[] = { 1, 2, 3, 4, 5, 6, 7 };
    List<int> l(array, sizeof(array) / sizeof(array[0]));
    cout << l << endl;

    l.PushBack(8);
    l.PushFront(0);
    cout << l << endl;
    cout << l.Size() << endl;

    List<int>::Iterator pos = l.Find(2);
    l.Insert(pos, 7);
    cout << l << endl;


    l.Erase(pos);
    cout << l << endl;

    l.Clear();
    cout << l.Size() << endl;
}
void TestList2()
{
    int array[] = { 1, 2, 3, 4, 5, 6, 7 };
    List<int> s1(array, sizeof(array) / sizeof(array[0]));
    cout <<"s1="<< s1 << endl;

    List<int> s2(s1);
    cout <<"s2(s1): s2="<< s2 << endl;

    List<int> s3 = s1;
    cout << "s3=s1: s3=" << s3 << endl;
}

int main()
{
    TestList1();
    TestList2();
    getchar();
    return 0;
}

运行结果：

lxi__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL库string类的模拟实现
02-28
类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。 总结： 1. string是表示字符串的字符串类 2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的...
STL详解— list类的模拟实现
最新发布
qq_61213622的博客
05-24 250
STL详解— list类的模拟实现
STL模拟实现
weixin_44032272的博客
02-24 247
GITHUB链接： https://github.com/Zruzhuo/C_Realize/tree/master/stl_string
stl——模拟实现vector
smx_dd的博客
01-13 384
对于vector相信大家并不陌生，这里介绍一些重要的vector的接口和用法。 1. 构造函数 vector(); 无参构造 vector(size_type n, const value_type& val = value_type()); 构造并初始化n个val vector (InputIterator first, InputIterator last); 利用迭代器进行构造。 ...
【STL】模拟实现vector
ArchyLi
03-22 934
本文初步用C++模拟实现vector的一下几个步骤，因为是初步实现，和STL库中的源码还有些不一样，后期会使用类似STL中的vector的三个迭代器再次模拟实现vector。 void PushBack(const DataType& data); void PopBack(); void Insert(size_t pos, const DataType& data); void Eras
STL：模拟实现Vector
dangzhangjing97的博客
08-11 729
一、vector是什么？ vector是STL中的容器之一，相当于动态的数组（或者顺序表） 二、vector的优点？ 1.效率高 2.通用性好（因为vector使用了模板，所以通用性强） ps：在需要用数组的地方，可优先考虑使用vector 三、vector的缺点？ 不适合头插和头删 因为vector相当于是动态的数组，所以vector不适合频繁的在空...
双向链表List模板类（模拟STL容器中的list）
02-07
双向链表List模板类（模拟STL容器中的list），提供插入删除，清空，获取链表长度，判断链表是否为空等操作，内置了迭代器类型
cpp-soa-iterator:使用 c++ struct-of-array 迭代器进行实验
06-06
cpp-soa-迭代器尝试使用 c++ struct-of-array 迭代器。动机数组结构数据模式通常用于 CUDA 代码以允许合并内存访问。 C++ STL 中的vector容器和thrust device_vector容器可以很容易地用于实现结构数组数据模式。 ...
使用频率计数器和OLED显示屏的金属探测器-电路方案
04-20
如您所见，OLED显示屏连接到Arduino的I2C接口，电池分压器连接到A0模拟引脚，而来自搜索线圈振荡器的信号直接连接到数字引脚5。 振荡器从串联的两个18650电池接收直接功率，并输出产生的信号。这是从线圈接收到的...
C++数据抽象和问题求解（第6版）.[美]Frank M. Carrano(带详细书签).pdf
01-08
C6.1.3 实现迭代器 483 C6.2 迭代器的高级功能 485 第17章 堆 489 17.1 ADT堆 490 17.2 堆的基于数组的实现 493 17.2.1 基于数组的堆操作的算法 494 17.2.2 实现 498 17.3 ADT优先队列的堆实现 502 17.4 堆...
模拟实现STL中的vector
ChaseRaod的博客
09-17 374
在之前的文章模拟实现源码剖析了STL中的List，这篇文章模拟STL中的vector. 模拟实现STL中的list 《STL源码剖析》中对vector的描述是这样的： vector的数据安排以及操作方式，与array非常相似。两者的唯一区别在于空间运用的灵活性。array是静态空间，一旦配置了就不能改变。vector是动态空间，随着元素的加入，它的内部机制会自行扩充空间以容纳新元素。 vec
STL——list使用和模拟
qq_62745420的博客
08-31 228
在STL中list底层使用的是双向带头循环链表，这是一个很完善的结构，可以做到在O（1）时间内完成任意位置的插入和删除。唯一的缺点就是不支持随机访问，如果要访问list中的第三个元素，只能通过遍历比如迭代器或者范围for来遍历到第三个元素。所以list不支持算法库里面的sort（因为算法库中的sort底层是快速排序，快速排序为了防止最坏的情况也就是已排序好的数据，在这种情况下的效率就是O（N^2)因此引入了三数取中，但是如果不支持随机访问，三数取中就不可以使用了）...
[CF# 366 Thor] STL模拟
Fighting!
08-09 633
[CF# 366 Thor] STL模拟 题目链接：[CF# 366 Thor]  题意描述：N 种物品标号为1~N， Q次操作： 标号为x 的物品增加一个；将标号为x的物品全部删除；将最初加入的前t次物品全部删除。 解题思路：想了好久，就是想不到模拟。 竟然一直想着用树状数组求和.... 直接看官方题解吧.... Consider a queue e fo
简单实现STL的迭代器Iterator
qq_41949110的博客
06-14 201
自己动手实现STL的迭代器. 我将在本偏文章中STL中的List链表类来当做例子,来实现迭代器原理.所以对链表不太熟悉的也可以进来看看. 迭代器说到底就是将数据层和用户交互层中间增加一个外壳，让用户不用关心底层数据存储和管理是如何实现，在保护了数据的同时也更加方便了用户的使用。 首先list是个模板链表类 首先声明类 template <typename T> class List { }; 2.为了用链表的方式存储数据,类中必须有一个不能让用户看到的结点结构体,方便管理链表，类中还必
STL模拟实现vector
IT_iverson的博客
10-31 473
首先给出所需要实现的函数接口和类的封装 template class Vector { public: Vector();//无参构造函数 Vector(const T* array, size_t size);//有参数构造函数 Vector(const Vector & v);//拷贝构造函数 Vector& operator=(const Vector& s);//赋值运算符重载
用指针模拟迭代器操作
Stephen___Qin的博客
04-15 97
// ios::exceptions #include <iostream> using namespace std; int main () { //只要指针指向数组元素,就可以对它进行下标操作. char c[6] = "hello"; char * pc = &c[2]; cout << "*pc:" << *pc << endl; cout << "*pc[-2]:" <<
STL的模拟实现
qq_57283958的博客
05-30 182
string的模拟实现 #pragma once #include<iostream> #include<string.h> #include<assert.h> namespace bit { class string { public: typedef char* iterator; typedef const char* const_iterator; iterator begin() { return _str; } iterator e
STL_string模拟实现
qq_44777506的博客
10-25 167
stringstring介绍：代码：代码实现：代码测试：测试结果：注意事项： string介绍： string是表示字符串的字符串类 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。 string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string; 不能操作多字节或者变长字符的序列 代码： 代码实现： namespace ZYY { cla
【STL】 vector 模拟实现
pointer_y的博客
09-23 2010
上一篇博客说了一下list的使用，其实vector用法基本上和list是一样的，所以此篇博客就只模拟实现以下vector。vector你可以把它理解成一个顺序表或者数组。只是STL里的vector是由三个迭代器来维护的：_start(数据存放开始的位置),_finish(数据存放结束位置的下一个),_endofstorage(容量的最后一个位置)。vector里的迭代器其实就是个指针。来看看代码实
利用stl算法和迭代器编程实现堆排序
05-18
下面是一个使用STL算法和迭代器实现堆排序的示例代码： ```c++ #include #include #include using namespace std; int main() { vector<int> arr = { 5, 3, 8, 4, 2 }; // 将数组转换为最大堆 make_heap...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值