stl源码——底层调用的算法

底层算法

    // 为算法提供基础  
    // T 是迭代器类型
    template <class T1, class T2>
    inline bool equal(T1 first1, T1 last1, T2 first2)
    {
        for (; first1 != last1; first1++, first2++)
        {
            if (*first1 != *first2)
            {
                return false;
            }
        }

        return true;
    }

    template <class T1, class T2, class T3>
    inline bool equal(T1 first1, T2 last1, T2 first2, T3 binary_pred)
    {
        // binary_pred 自定义的比较器
        for (; first1 != last1; first1++, first2++)
        {
            if (binary_pred(*first1, *first2) == false)
            {
                return false;
            }
        }

        return true;
    }

    template <class T1, class T2>
    void fill(T1 first, T1 last, const T2& value)
    {
        for (; first != last; first++)
        {
            *first = value;
        }
    }

    // 返回填补之后的结尾处
    template <class T1, class T2, class T3>
    T1 fill_n(T1 first, T2 n, const T3& value)
    {
        for (; n > 0; n--, first++)
        {
            *first = value;
        }
        return first;
    }

    template <class T1, class T2>
    inline void iter_swap(T1 a, T2 b)
    {
        return __iter_swap(a, b, value_type_t<T1>());
    }

    template <class T1, class T2, class T3>
    inline void __iter_swap(T1 a, T2 b, T3)
    {
        T3 temp  = *a;
        *a = *b;
        *b = temp;
    }

    template <class T1, class T2>
    bool lexicographical_compare(T1 first1, T1 last1, T2 first2, T2 last2)
    {
        for (; first1 != last1 && first2 != last2; ++first1, ++first2)
        {
            if (*first1 < *first2)
            {
                return true;
            }
            else if (*first1 > *first2)
            {
                return false;
            }
        }
        return first1 == last1 && first2 != last2;
    }

    template <class T>
    inline const T& max(const T& a, const T& b)
    {
        return a < b ? b : a;
    }

    template <class T1, class T2>
    inline const T1& max(const T1& a, const T1& b, T2 comp)
    {
        return comp(b, a) ? b : a;
    }

    template <class T>
    inline const T& min(const T& a, const T& b)
    {
        return a > b ? b : a;
    }

    template <class T1, class T2>
    inline const T1& min(const T1& a, const T1& b, T2 comp)
    {
        return comp(b, a) ? b : a;
    }

    template <class T1, class T2, class C>
    bool lexicographical_compare(T1 first1, T1 last1, T2 first2, T2 last2, C comp)
    {
        for (; first1 != last1 && first2 != last2; first1++, first2++)
        {
            if (comp(*first1, *first2) == true)
            {
                return true;
            }
            else if (comp(*first2, *first1) == true)
            {
                return false;
            }
        }

        return first1 == last1 && first2 == last2;  // 到末尾了  返回true
    }   

    inline bool lexicographical_compare(const unsigned char* first1, const unsigned char* last1,
                                        const unsigned char* first2, const unsigned char* last2)
    {
        const size_t len1 = last1 - first1;
        const size_t len2 = last2 - first2;

        const int res = memcmp(first1, first2, min(len1, len2));  // 比较最短长度

        // ==0都相同要比价长度  有不相同的直接比较即可
        return res != 0 ? res < 0 : len1 < len2;
    }

    template <class T1, class T2>
    pair<T1, T2> mismatch(T1 first1, T1 last1, T2 first2, T2 last2)
    {
        // 找到两个迭代器指向的链表的，第一个不同的元组
        while (first1 != last1 && (*first1 == *first2))
        {
            first1++;
            first2++;
        }

        return pair<T1, T2>(*first1, *first2);
    }

    template <class T1, class T2, class T3>
    pair<T1, T2> mismatch(T1 first1, T1 last1, T2 first2, T2 last2, T3 cmp)
    {
        // 找到两个迭代器指向的链表的，第一个不同的元组
        while (first1 != last1 && cmp(*first1 ,*first2) == true)
        {
            first1++;
            first2++;
        }

        return pair<T1, T2>(*first1, *first2);
    }


    template <class T>
    inline void swap(T& a, T& b)
    {
        T cp = a;
        a = b;
        b = cp;
    }

    template <class T1, class T2>
    class __copy_dispatch
    {
        T2 operator()(T1 first, T1 last, T2 result)
        {
            // 根据迭代器类型选择，进行不同的重载函数
            return __copy(first , last, result, iterator_category_t<T1>());
        }
    };

    template <class T>  // 偏特化 指针
    class __copy_dispatch<T*, T*>
    {
        T* operator()(T* first, T* last, T* result)
        {
            using t = typename _type_traits<T>::has_trival_assignment_operator;
            return __copy_t(first, last, result, t());
        }
    };

    template <class T>
    class __copy_dispatch<const T*, T*>
    {
        T* operator()(const T* first, const T* last, T* result)
        {
            using t = typename _type_traits<T>::has_trival_assignment_operator;
            return __copy_t(first, last, result,t());
        }
    };

    template <class T, class R>
    inline R copy(T first, T last, R result)
    {
        // 调用括号运算符
        return __copy_dispatch<T, R>()(first, last, result);
    }

    inline char* copy(const char* first, const char* last, char* result)
    {
        // 赋值首地址，源地址，长度  返回尾地址
        memmove(result, first, last - first);
        return result + (last - first);
    }

    template<class T, class R>
    inline R __copy(T first, T last, R result, input_iterator_tag)
    {
        // 对输入迭代器的重载
        for (; first != last; ++first, ++result)
        {
            *result = *first;
        }
        return result;
    }

    template <class T, class R>
    inline R __copy(T first, T last, R result, random_access_iterator_tag)
    {
        return __copy_d(first, last, result, difference_type_t<T>()); // 再细分
    }

    template <class T, class R, class D>
    inline R __copy_d(T first, T last, R result, D)
    {
        for (D n = last - first; n > 0; n--, ++first, ++result)
        {
            *result = *first;
        }
        return result;
    }

    template <class T>  // true  pod  普通类型  直接拷贝
    inline T* __copy_t(const T* first, const T* last, T* result, _true_type)
    {
        memove(result, first, sizeof(T) * (last - first));
        return result + (last - first);
    }

    template <class T>
    inline T* __copy(const T* first, const T* last, T* result, _false_type)
    {
        return __copy_d(first, last, result, ptrdiff_t());
    }

    template <class T1, class T2, class D>
    inline T2 __copy_backward(T1 first, T1 last, T2 result, bidirectional_iterator_tag, D)
    {
        // 从尾向头，元素复制到res  返回复制后的头res
        while (first != last)
        {
            --result;
            --last;
            *result = *last;
        }
        return result;
    }
    
    template <class T1, class T2, class D>
    inline T2 __copy_backward(T1 first, T1 last, T2 result, random_access_iterator_tag, D)
    {
        for (D n = last - first; n > 0; n--)
        {
            --result;
            --last;
            *result = *last;
        }
        return result;
    }

    template <class T1, class T2, class B>
    class __copy_backward_dispatch
    {
        T2 operator()(T1 first, T1 last, T2 result)
        {
            return __copy_backward(first, last, result, iterator_category_t<T1>(), difference_type_t<T1>());
        }
    };

    // 偏特化指针
    template <class T>
    class __copy_backward_dispatch<T *, T *, _true_type>
    {
    public:
        T *operator()(const T *first, const T *last, T *result)
        {
            const ptrdiff_t n = last - first;
            memmove(result - n, first, sizeof(T) * n);
            return result - n;
        }
    };

    // 偏特化常指针  常指针调用普通指针
    template<class T>
    class __copy_backward_dispatch<const T*, T* , _true_type>
    {
    public:
        T *operator()(const T* first, const T* last, T* result)
        {
            return __copy_backward_dispatch<T*, T*,_true_type>()(first, last, result);
        }
    };
 
    template<class T1, class T2>
    inline T2 copy_backward(T1 first, T1 last, T2 result)
    {
        using trival = typename _type_traits<
            value_type_t<T2>>::has_trivial_assignment_operator;
        return __copy_backward_dispatch<T1, T2,trival>()(first, last, result);
    }