将向量转换为常数唯一性_ptr

Question

如何将向量转换/复制为唯一的\u ptr

这就是我想要实现的（向量起源于另一个上下文，在复制到unique_ptr后将被删除。unique_ptr具有固定长度，因此可以更有效地分配）。

std::vector<int> vv {1, 2, 3};

struct
    U {
        U(std::vector<int> v) { // copy constructor
            // copy vector v to unique_ptr u, HOW?
        }

        std::unique_ptr<int[]> u; 
};


U uu {vv}; // copy vector vv to unique_ptr uu, HOW?

我试图复制一个构造器

U(std::vector<int> v) {
    u = std::make_unique<int[]>(v.size()); // OK
    std::copy(v.begin(), v.end(), u); // error: u has no copy constructor
}

那么，我应该如何构造复制构造函数呢？

实际上，而且，一旦构建，我想要unique_ptr

std::unique_ptr<int const[]> const u; // const in both length and content

在这两种情况下，复制构造函数的外观如何？

案例1）std：：唯一性

Answer 1

我试图复制一个构造器

这不是复制构造函数。这是一个转换构造函数。

std::copy(v.begin(), v.end(), u); // error: u has no copy constructor

std::copy的第三个参数必须是迭代器，就像前两个一样。std::unique_ptr不是迭代器。

唯一指针指向一个数组。指针是数组的迭代器。所以，你需要的是一个指针。如何从唯一指针获取指针？使用std:：unique_ptr:：get成员函数。

通过接受模板迭代器（或范围）而不是向量，可以使构造函数更通用。作为奖励，你可以避免复制两次（这也可以通过使用引用来避免）。

unique_ptr长度固定，因此可以更有效地分配

向量和动态数组（例如由唯一指针管理的数组）的分配方式几乎没有区别。即使存在一些差异，复制输入向量进行转换的效率也比不复制要低得多。

Answer 2

你正在做的事情有几个问题。首先你有两个副本而不是一个（在U构造函数中），然后因为你需要在你的u上得到实际的迭代器，而不是u本身。

对于const正确性，您可以只有一个中间唯一指针，允许更改数据。

您拥有的最终代码应该如下所示：

struct U {
    U(const std::vector<int>& v) {
        auto data = std::make_unique<int[]>(v.size());
        std::copy(v.begin(), v.end(), data.get());
        u = std::move(data);
    }

    std::unique_ptr<int const[]> u; 
};

注意：向量的效率与唯一指针的效率一样。数据访问模式将是相同的。只有当你将_推回它，或将其删除时，才会产生开销。由于您不需要执行这些操作，只需存储一个常量向量。

如果你想要一个constd::unique_ptr

struct U {
    U(std::unique_ptr<int const[]>&& u)
    : u(std::move(u)) {}

    static U create(const std::vector<int>& v) {
        auto data = std::make_unique<int[]>(v.size());
        std::copy(v.begin(), v.end(), data.get());
        std::unique_ptr<int const[]> u = std::move(data);
        return U(std::move(u));
    }

    const std::unique_ptr<int const[]> u; 
};