《STL源码分析》学习笔记 — 空间配置器 — 内存基本处理工具

stl_uninitialized.h 文件中提供了用于处理未初始化内存的几个低层次函数： uninitialized_copy、 uninitialized_fill 和 uninitialized_fill_n，分别对应于高层次的 copy、 fill、 fill_n。 uninitialized 版本的函数都是针对于原始内存的，因此它们通过定位 new 运算符实现对象构造。非 uninitialized 版本的函数则是针对已经构造好的内存进行赋值。

一、uninitialized_copy

template<bool _TrivialValueTypes>
struct __uninitialized_copy
{
   
    template<typename _InputIterator, typename _ForwardIterator>
    static _ForwardIterator __uninit_copy(_InputIterator __first, _InputIterator __last,
                  _ForwardIterator __result)
    {
   
        _ForwardIterator __cur = __result;
        __try
        {
   
            for (; __first != __last; ++__first, (void)++__cur)
                std::_Construct(std::__addressof(*__cur), *__first);
            return __cur;
        }
        __catch(...)
        {
   
            std::_Destroy(__result, __cur);
            __throw_exception_again;
        }
    }
};

template<>
struct __uninitialized_copy<true>
{
   
    template<typename _InputIterator, typename _ForwardIterator>
    static _ForwardIterator __uninit_copy(_InputIterator __first, _InputIterator __last,
                  _ForwardIterator __result)
    {
    return std::copy(__first, __last, __result); }
};

__uninitialized_copy 是一个辅助类。当其类型参数为true 时，直接调用 copy 函数。当其类型参数为 false 时，__uninit_copy 在迭代器范围内循环调用 _Construct 函数拷贝构造对象。这里使用了 try-catch 语句捕获了异常，其目的在于：如果任意一个对象构造出现异常，则将已经构造好的所有对象析构，将内存返回到未初始化状态。这也暗示我们在析构函数中绝对不应该抛出异常，否则会造成内存泄漏。注意指定拷贝范围的两个入参为输入迭代器，目标迭代器为前向迭代器。函数返回值为指向最后一个被构造的元素后一个元素的前向迭代器。

/**
   *  @brief Copies the range [first,last) into result.
   *  @param  __first  An input iterator.
   *  @param  __last   An input iterator.
   *  @param  __result An output iterator.
   *  @return   __result + (__first - __last)
   *
   *  Like copy(), but does not require an initialized output range.
  */
template<typename _InputIterator, typename _ForwardIterator>
inline _ForwardIterator uninitialized_copy(_InputIterator __first, _InputIterator __last,
                   _ForwardIterator __result)
{
   
    typedef typename iterator_traits<_InputIterator>::value_type
            _ValueType1;
    typedef typename iterator_traits<_ForwardIterator>::value_type
            _ValueType2;
#if __cplusplus < 201103L
    const bool __assignable = true;
#else
    // Trivial 类型可能含有被删除的拷贝构造函数, 但是借助使用 memmove 进行拷贝的 std::copy 函数无论如何都能拷贝内存。
    static_assert(is_constructible<_ValueType2, decltype(*__first)>::value,
            "result type must be constructible from value type of input range");

    typedef typename iterator_traits<_InputIterator>::reference _RefType1;
    typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
    // Trivial 类型可能含有被删除的赋值操作符, 这样 std::copy 的行为将是不确定的。 因此使用 std::copy 需要确保赋值操作符的存在。
    const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
#endif

    return std::__uninitialized_copy<__is_trivial(_ValueType1)
            && __is_trivial(_ValueType2)
            && __assignable>::
            __uninit_copy(__first, __last, __result);
}

函数头部的注释指明了 uninitialized_copy 与 std::copy 的区别，前者不需要已经初始化好的内存空间。中间使用 static_assert 保证从输入类型到输出类型的拷贝构造是存在的。返回时，uninitialized_copy 借助 __uninitialized_copy 实现内存初始化。那么什么情况下直接调用 std::copy，什么情况下调用定位 new呢？
当以下三个条件同时满足时，将直接调用 std::copy：源类型为 POD，目标类型为 POD，能够将源类型的对象赋值给目标类型。前两个条件满足，则不需要编译器通过 new 运算符进行 vptr、vbtable 的设置，第三个条件满足，std::copy 模板函数才能为该类型实例化。
代码中有两段注释解释了调用 std::copy 的判断条件。其实，它们并不会同时其作用（源码以后再分析）。当类型为 trivial 时，std::copy 其实也有两个版本，主要是通过 __are_same<_ValueType1, _ValueType2>::__value 进行区分的。当输入类型和输出类型相同（且参数类型为指针）时才会调用 memmove；否则调用赋值操作符。uninitialized_copy 并没有详细的区分这两种情况。它要求两个条件都满足ÿ