C++11标准模板（STL）- 动态内存管理 - 未初始化存储 - 复制一个对象到以范围定义的未初始化内存区域 - （std::uninitialized_fill）

动态内存管理

未初始化存储

提供数个工具以创建并访问未初始化存储

复制一个对象到以范围定义的未初始化内存区域

std::uninitialized_fill

template< class ForwardIt, class T > void uninitialized_fill( ForwardIt first, ForwardIt last, const T& value );	(1)
template< class ExecutionPolicy, class ForwardIt, class T > void uninitialized_fill( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, const T& value );	(2)	(C++17 起)

1) 复制给定的 value 到以 [first, last) 定义的未初始化内存区域，如同用

for (; first != last; ++first)
  ::new (static_cast<void*>(std::addressof(*first)))
      typename std::iterator_traits<ForwardIt>::value_type(x);

若初始化期间抛异常，则以未指定顺序销毁已构造的对象。

2) 同 (1) ，但按照 policy 执行。此重载仅若 std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> 为 true 才参与重载决议。

参数

first, last	-	要初始化的元素的范围
value	-	构造元素所用的值
policy	-	所用的执行策略。细节见执行策略。
类型要求
- ForwardIt 必须满足遗留向前迭代器 (LegacyForwardIterator) 的要求。
- 通过 ForwardIt 合法实例的自增、赋值、比较或间接均不可抛异常。

返回值

（无）

复杂度

与 first 和 last 间的距离成线性

异常

拥有名为 ExecutionPolicy 的模板形参的重载按下列方式报告错误：

• 若作为算法一部分调用的函数的执行抛出异常，且 ExecutionPolicy 为标准策略之一，则调用 std::terminate 。对于任何其他 ExecutionPolicy ，行为是实现定义的。
• 若算法无法分配内存，则抛出 std::bad_alloc 。

可能的实现

template<class ForwardIt, class T>
void uninitialized_fill(ForwardIt first, ForwardIt last, const T& value)
{
    typedef typename std::iterator_traits<ForwardIt>::value_type Value;
    ForwardIt current = first;
    try
    {
        for (; current != last; ++current)
        {
            ::new (static_cast<void*>(std::addressof(*current))) Value(value);
        }
    }
    catch (...)
    {
        for (; first != current; ++first)
        {
            first->~Value();
        }
        throw;
    }
}

调用示例

#include <iostream>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>
#include <time.h>
#include <random>
#include <vector>
#include <cassert>

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }


    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator >(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y > cell.y;
        }
        else
        {
            return x > cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }

    friend Cell operator+(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x += rcell.x;
        cell.y += rcell.y;
        return cell;
    }

    friend Cell operator-(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x -= rcell.x;
        cell.y -= rcell.y;
        return cell;
    }

    friend Cell operator*(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x *= rcell.x;
        cell.y *= rcell.y;
        return cell;
    }

    friend Cell operator/(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x /= rcell.x;
        cell.y /= rcell.y;
        return cell;
    }

    friend Cell operator%(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x %= rcell.x;
        cell.y %= rcell.y;
        return cell;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

namespace _std
{
template<class ForwardIt, class T>
void uninitialized_fill(ForwardIt first, ForwardIt last, const T& value)
{
    typedef typename std::iterator_traits<ForwardIt>::value_type Value;
    ForwardIt current = first;
    try
    {
        for (; current != last; ++current)
        {
            ::new (static_cast<void*>(std::addressof(*current))) Value(value);
        }
    }
    catch (...)
    {
        for (; first != current; ++first)
        {
            first->~Value();
        }
        throw;
    }
}
}

int main()
{
    std::cout << std::boolalpha;

    std::mt19937 g{std::random_device{}()};
    srand((unsigned)time(NULL));

    auto generate = []()
    {
        int n = std::rand() % 10 + 110;
        Cell cell{n, n};
        return cell;
    };

    //3) 构造拥有 count 个有值 value 的元素的容器。
    std::vector<Cell> vector1(8, generate());
    std::generate(vector1.begin(), vector1.end(), generate);
    std::sort(vector1.begin(), vector1.end());
    std::cout << "vector1:  ";
    std::copy(vector1.begin(), vector1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::vector<Cell> vector2(vector1.size(), Cell{101, 101});
    std::generate(vector2.begin(), vector2.end(), generate);
    std::sort(vector2.begin(), vector2.end());
    std::cout << "vector2:  ";
    std::copy(vector2.begin(), vector2.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    std::vector<Cell> vector3;
    // 为vector3预留空间
    vector3.resize(vector1.size());
    std::uninitialized_fill(vector3.begin(), vector3.end(), generate());
    std::cout << "vector3:  ";
    std::copy(vector3.begin(), vector3.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << "vector1:  ";
    std::copy(vector1.begin(), vector1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    std::vector<Cell> vector4;
    // 为vector3预留空间
    vector4.resize(vector2.size());
    std::uninitialized_fill(vector4.begin(), vector4.end(), generate());
    std::cout << "vector4:  ";
    std::copy(vector4.begin(), vector4.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << "vector2:  ";
    std::copy(vector2.begin(), vector2.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    return 0;
}

输出

vector1:  {110,110} {111,111} {112,112} {112,112} {113,113} {117,117} {117,117} {118,118}
vector2:  {110,110} {111,111} {112,112} {114,114} {117,117} {119,119} {119,119} {119,119}

vector3:  {110,110} {110,110} {110,110} {110,110} {110,110} {110,110} {110,110} {110,110}
vector1:  {110,110} {111,111} {112,112} {112,112} {113,113} {117,117} {117,117} {118,118}

vector4:  {111,111} {111,111} {111,111} {111,111} {111,111} {111,111} {111,111} {111,111}
vector2:  {110,110} {111,111} {112,112} {114,114} {117,117} {119,119} {119,119} {119,119}