stl源码——uninitialized

最新推荐文章于 2024-07-23 18:35:33 发布

晗光。

最新推荐文章于 2024-07-23 18:35:33 发布

阅读量49

点赞数

文章标签： c++ c语言数据结构

本文链接：https://blog.csdn.net/hhw19970108/article/details/130408356

版权

template <class T, class R>
    inline R uninitialized_copy(T first, T last, R result)
    {
        using isPODType = typename _type_traits<value_type_t<T>>::is_POD_type;
        return __uninitialized_copy_aux(first, last, result, isPODType()); // 调用括号运算符/ 对象
    }

    template <class T, class R>
    inline T __uninitialized_copy_aux(T first, T last, R result, _true_type)
    {
        return MiniSTL::copy(first, last, result); // first到last 复制到result   pod 普通类型
    }

    template <class T, class R>
    inline T __uninitialized_copy_aux(T first, T last, R result, _false_type)
    {
        // 非pod类型
        R cur = result;
        for (; first != last; first++, cur++)
        {
            construct(&*cur, *first); // 在cur地址 构造值为*first的值的对象
        }
        return cur;
    }

    inline char * uninitialized_copy(const char* first, const char * last, char * result)
    {
        memmove(result, first, last - first);
        return result + (last - first);
    }
    
    inline wchar_t* uninitialized_copy(const wchar_t* first, const wchar_t* last, wchar_t* result)
    {
        memmove(result, first, last - first);
        return result + (last - first);
    }

// 区间填充value
    template <class T, class R>
    inline void uninitialized_fill(T first, T last, const R& value)
    {
        using isPODType = typename _type_traits<value_type_t<T>>::is_POD_type;
        __uninitialized_fill_aux(first, last, isPODType());
    }

    template <class T, class R>
    inline void __uninitialized_fill_aux(T first, T last, const R& value, _true_type)
    {
        MiniSTL::fill(first, last, value);
    }

    template <class T, class R>
    inline void __uninitialized_fill_aux(T first, T last, const R& value, _false_type)
    {
        T cur = first;
        for (; cur != last; cur++)
        {
            construct(&*cur, value);
        }
    }

    template <class T1, class T2, class T3>
    inline T1 uninitialized_fill_n(T1 first, T2 n, const T3& value)
    {
        // 从first开始 的n个数填充为value
        using isPODType = typename _type_traits<T1>::is_POD_type;
        return __uninitialized_fill_n_aux(first, n , value, isPODType());
    } 

    template <class T1, class T2, class T3>
    inline T1 __uninitialized_fill_n_aux(T1 first, T2 n, const T3 &value,_true_type)
    {
        return MiniSTL::fill_n(first, n, value);
    }

    template <class T1, class T2, class T3>
    inline T1 uninitialized_fill_n_aux(T1 first, T2 n, const T3& value, _false_type)
    {
        T1 cur = first;
        for (; n > 0; n--,cur++)
        {
            construct(&*cur, value);
        }
        return cur;
    }

    template <class T1, class T2, class T3>
    inline T1 uninitialized_copy_copy(T1 first1, T1 last1, T2 first2, T2 last2, T3 result)
    {
        // f1 l1 放到res之后，f2，l2再放到res之后
        T1 mid = MiniSTL::uninitialized_copy(first1, last1, result);

        try
        {
            return MiniSTL::uninitialized_copy(first2,last2, mid);

        }
        catch(const std::exception& e)
        {
            // res 此时还在开头  如果有误，将原来拷贝的销毁，一致性操作
            destory(result, mid);
            throw;
        }
    }

    template <class T1, class T2, class T3>
    inline T1 uninitialized_fill_copy(T1 result, T1 mid, const T2& val, T3 first, T3 last)
    {
        // 从res 到mid填充到val
        MiniSTL::uninitialized_fill(result, mid, val);
        try
        {
            // res.mid,-----   val,mid,first,last
            return MiniSTL::uninitialized_copy(first, last, mid);
        }
        catch(const std::exception& e)
        {
            destory(result, mid);
            throw;
        }
    }

    template <class T1, class T2, class T3>
    inline void uninitialized_copy_fill(T1 first1, T1 last1, T2 first2, T2 last2, const T3& value)
    {
        T2 mid2 = MiniSTL::uninitialized_copy(first1, last1, first2);
        try
        {
            MiniSTL::uninitialized_fill(mid2, last2, value); // mid2 last2 value
        }
        catch(const std::exception& e)
        {
            destory(first1, mid2);
            throw;
        }
    }