stl源码——迭代器

迭代器基类

	// 公有的，直接使用struct
    struct input_iterator_tag
    {
    };
    struct output_iterator_tag
    {
    };
    struct forward_iterator_tag : public input_iterator_tag
    {
    };
    struct bidirectional_iterator_tag : public forward_iterator_tag
    {
    };
    struct random_access_iterator_tag : public bidirectional_iterator_tag
    {
    };

template <class Category, class T, class Distance = ptrdiff_t,
              class Pointer = T *, class Reference = T &>
class iterator
{
public:
    using iterator_category = Category;
    using value_type = T;
    using difference = Distance;
    using pointer = Pointer;
    using reference = Reference;
};

迭代器萃取

 // 迭代器萃取机  萃取机中的迭代器类型，就是协作类中迭代器类型
    // 萃取机中的值类型，就是协作类中的类类型
    // 萃取机中的指针类型，就是协作类中的指针类型
    template <class T>
    class iterator_traits
    {
    public:
        using iterator_category = typename T::iterator_category; // 迭代器类型 typename指的是类型
        using value_type = typename T::value_type;
        using difference_type = typename T::difference_type;
        using pointer = typename T::pointer;
        using reference = typename T::reference;
    };

迭代器萃取机的偏特化

// 对于指针类型的迭代器萃取机，该迭代器萃取机中迭代器类型是随机访问的
    // 该迭代器萃取机中值类型就是协作类类型
    // 该迭代器萃取机中指针类型就是协作类的指针类型
    template <class T>
    class iterator_traits<T *>
    {
    public:
        using iterator_category = random_access_iterator_tag;
        using value_type = T;
        using difference_type = ptrdiff_t;
        using pointer = T *;
        using reference = T &;
    };
    template <class T>
    class iterator_traits<const T *>
    {
    public:
        using iterator_category = random_access_iterator_tag;
        using value_type = T;
        using difference_type = ptrdiff_t;
        using pointer = const T *;
        using reference = const T &;
    };

萃取出的类型

 	template <class T>
    using iterator_category_t =
        typename iterator_traits<T>::iterator_category;
    template <class T>
    using value_type_t =
        typename iterator_traits<T>::value_type;
    template <class T>
    using difference_type_t =
        typename iterator_traits<T>::difference_type; // ptrdiff_t 距离
    template <class T>
    using pointer_t =
        typename iterator_traits<T>::pointer_t;
    template <class T>
    using reference_t =
        typename iterator_traits<T>::reference_t;

移动和计算距离

    // 计算两个区间的距离，
    template <class T>
    inline difference_type_t<T> __distance(T first, T last, input_iterator_tag)
    {
        // input_iterator_tag 作为重载的决议，stl的主要问题就是在编译时期完成了应该调用那个函数
        // 使用多态会影响效率，因此改为重载，而重载具体调用哪个，用tag来进行区分
        difference_type_t<T> n = 0;
        while (first != last)
        {
            ++first;
            ++n;
        }
        return n;
    }

    template <class T>
    inline difference_type_t<T> __distance(T first, T last, random_access_iterator_tag)
    {
        return last - first;
    }

    template <class T1>
    inline difference_type_t<T1> distance(T1 first, T1 last)
    {
        // 根据迭代器种类来判定调用哪个重载函数  迭代器种类就是协作类中迭代器的种类
        return __distance(first, last, iterator_category_t<T1>());
    }

    template <class T, class F>
    inline void __advance(T &it, F n, input_iterator_tag)
    {
        // 向前
        while (n--)
        {
            ++it;
        }
    }
    template <class T, class F>
    inline void __advance(T &it, F n, bidirectional_iterator_tag)
    {
        if (n >= 0)
        {
            while (n--)
            {
                ++it;
            }
        }
        else
        {
            while (n++)
            {
                --it;
            }
        }
    }
    template <class T, class F>
    inline void __advance(T &it, F n, random_access_iterator_tag)
    {
        it += n;
    }

    template <class T, class F>
    inline void advance(T& it, F n)
    {
        // 通过协作类的迭代器种类来进行重载判定具体调用哪个函数
        __advance(it, n, iterator_category_t<T>());
    }

三种迭代器适配器 insert reverse stream

insert

    template <class T>
    class back_insert_iterator
    {
    protected:
        T *container; // 容器数组，T类型数组，

    public:
        using iterator_category = output_iterator_tag;
        using value_type = void;
        using difference_type = void;
        using pointer = void;
        using reference = void;

    public:
        // cp ctor
        explicit back_insert_iterator(T &value) : container(value) {}

        back_insert_iterator& operator=(const typename T::value_type &value)
        {
            container->push_back(value);
            return *this;
        }

        // 三个无用接口 不操作
        back_insert_iterator operator*()
        {
            return *this;
        }

        back_insert_iterator operator++()
        {
            return *this;
        }

        back_insert_iterator operator++(int)
        {
            return this;
        }
    };

    template <class T>
    inline back_insert_iterator<T> back_inserter(T& x)
    {
        // 构造后插迭代器   形如 A x; A* a(&x)
        return back_insert_iterator<T>(x);
    }

    template <class T>
    class front_insert_iterator
    {
    protected:
        // 疑问 这里是指针吗？
        T *container;
    
    public:
        using iterator_category = output_iterator_tag;
        using value_type = void;
        using difference_type = void;
        using pointer = void;
        using reference = void;

    public:
        // 如果上述是指针，这里是没办法赋值的
        explicit front_insert_iterator(T& value) : container(value) {}
        front_insert_iterator& operator=(const typename T::value_type& value)
        {
            container->push_front(value);
            return *this;
        }
        front_insert_iterator operator*()
        {
            return *this;
        }

        front_insert_iterator operator++()
        {
            return *this;
        }

        front_insert_iterator operator++(int)
        {
            return *this;
        }
    };

    template <class T>
    inline front_insert_iterator<T> front_insert(T& x)
    {
        // 前插迭代器
        return front_insert_iterator<T>(x);
    }

    template <class T>
    class insert_iterator
    {
    protected: 
        T* container;  // 这里应该是指针吗？ 不理解
        typename T::iterator iter; // 类类型A中的迭代器类型

    public:
        using iterator_category = output_iterator_tag;
        using value_type = void;
        using difference_type = void;
        using pointer = void;
        using reference = void;

    public:
        insert_iterator(T& value, typename T::iterator i)
        : container(value) , iter(i){}

        insert_iterator &operator=(const typename T::value_type &value)
        {
            container->insert(iter, value);
            ++iter;
            return *this;
        }

        insert_iterator operator*()
        {
            return *this;
        }
        insert_iterator operator++()
        {
            return *this;
        }
        insert_iterator operator++(int)
        {
            return *this;
        }
    };

    template <class T,class It>
    inline insert_iterator<T> inserter(T& x, It it)
    {
        return insert_iterator<T>(x, it);
    }

reverse

    template<class T>
    class __reverse_iterator
    {
    public:
        template<class IT>
        friend bool operator==(const __reverse_iterator <IT>&, const __reverse_iterator <IT> &);

        template <class IT>
        friend bool operator!=(const __reverse_iterator <IT> &, const __reverse_iterator <IT> &);

    protected:
        T current;

    public:
        using iterator_category = iterator_category_t<T>;
        using value_type = value_type_t<T>;
        using difference_type = difference_type_t<T>;
        using pointer = pointer_t<T>;
        using reference = reference_t<T>;

        using iterator_type = T;
        using self = __reverse_iterator;

    public:
        // ctor
        __reverse_iterator(){}
        explicit __reverse_iterator(iterator_type value) : current(value){}
        __reverse_iterator(const self& value) : current(value.current) {}

        iterator_type base() const 
        {
            // 获取迭代器类型
            return current;
        }

        // 解引用 [12)  (12]
        reference operator*() const
        {
            T temp = current; // 对逆向迭代器取值，相当于对正向迭代器后退一个单位取值
            return *(--temp);
        }

        pointer operator->() const
        {
            // 指向，取地址，  
            return &(operator*());
        }

        self& operator++()
        {
            // 反向迭代器，与正向相反
            --current;
            return *this;
        }

        self operator++(int)
        {
            self cp = *this;
            --current;
            return cp;
        }

        self& operator--()
        {
            ++current;
            return *this;
        }

        self operator--(int)
        {
            self cp = this;
            current++;
            return cp;
        }

        // 迭代器的加法，相当于指针移动 逆向迭代器+，相当于底层指针-
        self operator+(difference_type n) const
        {
            return self(current - n);
        }

        self operator-(difference_type n) const
        {
            return self(current + n);
        }

        self& operator+=(difference_type n)
        {
            current -= n;
            return *this;
        }

        self& operator-=(difference_type n)
        {
            current += n;
            return *this;
        }

        reference operator[](difference_type n) const
        {
            return *(*this + n);
        }

        bool operator==(const self& rhs) const
        {
            return current == rhs.current;
        }
        
        bool operator!=(const self& rhs) const
        {
            return !(this != &this);
        }
    };

    // 两个迭代器比较
    template <class T>
    inline bool operator==(const __reverse_iterator<T> &lhs, const __reverse_iterator<T> &rhs)
    {
        return lhs == rhs;
    }

    template <class T>
    inline bool operator!=(const __reverse_iterator<T> &lhs, const __reverse_iterator<T> &rhs)
    {
        return !(lhs != rhs);
    }

    template <class T>
    inline bool operator<(const __reverse_iterator<T> &lhs, const __reverse_iterator<T> &rhs)
    {
        // 底层迭代器比较  根据逆向思想，lhs如果小，应该在数组的末端，其base应该大
        return rhs.base() < lhs.base();
    }

    template <class T>
    inline bool operator>(const __reverse_iterator<T> &lhs, const __reverse_iterator<T> &rhs)
    {
        return rhs.base() > lhs.base();
    }

    template <class T>
    inline bool operator<=(const __reverse_iterator<T> &lhs, const __reverse_iterator<T> &rhs)
    {
        return !(lhs > rhs); //   lhs.base() >= rhs.base()
    }

    template <class T>
    inline bool operator>=(const __reverse_iterator<T> &lhs, const __reverse_iterator<T> & rhs)
    {
        return !(lhs < rhs);
    }

stream

    template <class T, class Distance = ptrdiff_t>
    class istream_iterator
    {
    protected:
        std::istream *stream;
        T value;
        bool end_maker;
        void read()
        {
            end_maker = (*stream) ? true : false;
            if (end_maker == true)
            {
                * stream >> value;
            }
            // 完成输入后 endmaker可能发生了改变，再次判定
            end_maker = (*stream) ? true : false;
        }
    public:
        using iterator_category = input_iterator_tag;
        using value_type = T;
        using difference_type = Distance;
        using pointer = const T*;
        using reference = const T&;

        istream_iterator() : stream(&std::cin), end_maker(false) {}
        istream_iterator(std::istream &s) :stream(s)
        {
            read();
        }

        reference operator*() const
        {
            return value;
        }

        pointer operator->() const
        {
            return &(operator*());
        }

        istream_iterator &operator ++()
        {
            read();
            return *this;
        }

        istream_iterator operator++(int)
        {
            istream_iterator cp = *this;
            read();
            return cp;
        }
    };

    template <class T>
    class ostream_iterator
    {
    protected:
        std::ostream* stream;
        const char* interval;

    public:
        using iterator_category = output_iterator_tag;
        using value_type = void;
        using difference_type = void;
        using pointer = void;
        using reference = void;

        ostream_iterator & operator=(const T &value)
        {
            *stream << value;
            if (interval)
            {
                *stream << interval;
            }
            return *this;
        }

        ostream_iterator & operator*()
        {
            return *this;
        }

        ostream_iterator& operator++()
        {
            return *this;
        }
        ostream_iterator& operator++(int)
        {
            return *this;
        }
    };