C++ nullptr的唯一\u ptr是不可复制的

它看起来像是在尝试引用已删除的函数时创建了unique_ptr to null抛出的嵌套向量。我相信这是因为它试图复制向量unique_ptr（nullptr）的，unique_ptr（nullptr）是不可复制的

#include <memory>
#include <vector>
struct Foo {
};
int main() {
    std::vector<std::vector<std::unique_ptr<Foo>>> foo(5, std::vector<std::unique_ptr<Foo>>(5));
}

#包括
#包括
结构Foo{
};
int main（）{
std:：vector foo（5，std:：vector（5））；
}

---

我不知道如何进行。我只需要一个多维的nullptr数组，如果它们是唯一的，那就太棒了-除了解决这个问题，不需要共享ptr。

std:：unique\u ptr

就是不可复制的。这与

nullptr

无关。最简单的解决方法是只使用一维数组并映射维度

然后，您可以执行以下操作：

for (std::size_t j = 0; i < 5; ++j) {
    for (std::size_t i = 0; i < 5; ++i) {
        std::size_t index = j*5+i;
        foo.emplace_back(std::make_unique<Foo>());
    }
}

（标准：：尺寸j=0；i<5；++j）的

{
对于（标准：：尺寸i=0；i<5；++i）{
标准：尺寸指数=j*5+i；
foo.emplace_back（std:：make_unique（））；
}
}

---

（您可以将类似的模式应用于嵌套的

std:：vector

s，但这样在缓存位置等方面可能会更好）。

std:：unique\u ptr

是不可复制的。这与

nullptr

无关。最简单的解决方法是只使用一维数组并映射维度

然后，您可以执行以下操作：

for (std::size_t j = 0; i < 5; ++j) {
    for (std::size_t i = 0; i < 5; ++i) {
        std::size_t index = j*5+i;
        foo.emplace_back(std::make_unique<Foo>());
    }
}

（标准：：尺寸j=0；i<5；++j）的

{
对于（标准：：尺寸i=0；i<5；++i）{
标准：尺寸指数=j*5+i；
foo.emplace_back（std:：make_unique（））；
}
}

---

（您可以对嵌套的

std:：vector

s应用类似的模式，但这样在缓存位置等方面可能会更好）

如果由于向量中的每个嵌套向量元素具有不同的大小而需要嵌套多个向量，然后可以使用

std:：move

将唯一的PTR从一个向量移动到另一个向量

    std::vector<std::unique_ptr<Foo>> container1;
    std::vector<std::unique_ptr<Foo>> container2;
    for (int i = 0; i < 10; ++i)
    {
        container1.emplace_back(std::make_unique<Foo>());
    }

    for (int i = 0; i < 2; ++i)
    {
        container2.emplace_back(std::make_unique<Foo>());
    }

    std::vector<std::vector<std::unique_ptr<Foo>>> containers;
    containers.emplace_back(std::move(container1));
    containers.emplace_back(std::move(container2));

    return 0;

std:：向量容器1；
std：：载体容器2；
对于（int i=0；i<10；++i）
{
容器1.向后放置（std:：make_unique（））；
}
对于（int i=0；i<2；++i）
{
容器2.向后放置（std:：make_unique（））；
}
std：：载体容器；
集装箱。向后安放（标准：：移动（集装箱1））；
集装箱。向后安放（标准：：移动（集装箱2））；
返回0；

---

不过，映射是最快的解决方案。

如果由于向量中每个嵌套向量元素的大小不同而需要嵌套多个向量，则可以使用

std:：move

将唯一的PTR从一个向量移动到另一个向量

    std::vector<std::unique_ptr<Foo>> container1;
    std::vector<std::unique_ptr<Foo>> container2;
    for (int i = 0; i < 10; ++i)
    {
        container1.emplace_back(std::make_unique<Foo>());
    }

    for (int i = 0; i < 2; ++i)
    {
        container2.emplace_back(std::make_unique<Foo>());
    }

    std::vector<std::vector<std::unique_ptr<Foo>>> containers;
    containers.emplace_back(std::move(container1));
    containers.emplace_back(std::move(container2));

    return 0;

std:：向量容器1；
std：：载体容器2；
对于（int i=0；i<10；++i）
{
容器1.向后放置（std:：make_unique（））；
}
对于（int i=0；i<2；++i）
{
容器2.向后放置（std:：make_unique（））；
}
std：：载体容器；
集装箱。向后安放（标准：：移动（集装箱1））；
集装箱。向后安放（标准：：移动（集装箱2））；
返回0；

---

映射是最快的解决方案。

这与nullptr无关-unique\u ptr本身是不可压缩的，正如其名称所示。对。那么，我如何通过定义默认大小来创建一个多维的unique_ptr数组呢？不要使用

std:：vector

make first dimension的copy from element ctor，然后使用ranged for调整每个向量的内部维度。为什么要使用

vector

而不仅仅是

vector

？我想在将来的某个点将Foo的所有权分配给向量

vector Foo；foo.at（2）=std:：make_unique（）。这就是为什么他们现在是nullptr的原因。这与nullptr无关-unique_ptr本身是不可复制的，正如它的名字所暗示的。对。那么，我如何通过定义默认大小来创建一个多维的unique_ptr数组呢？不要使用
std:：vector
make first dimension的copy from element ctor，然后使用ranged for调整每个向量的内部维度。为什么要使用
vector
而不仅仅是
vector
？我想在将来的某个点将Foo的所有权分配给向量
vector Foo；foo.at（2）=std:：make_unique（）。这就是为什么它们现在是空ptr的原因。事实上，这不仅更简单，而且更快（仅一个间接寻址，更少的分配…），并且比嵌套的
std:：vector
内存占用更小。嵌套的
std:：vector
只有当你真的有一个不可预测的、大小不同的向量时才应该使用。同意；但是，我不能使用
std:：array
，因为我不知道compliation:n的大小是通过构造函数传递的。事实上，这不仅简单，而且速度更快（仅一个间接寻址，分配更少…），并且比嵌套的
std:：vector
内存占用更小。嵌套的
std:：vector
只有当你真的有一个不可预测的、大小不同的向量时才应该使用。同意；但是，我不能使用std:：array，因为我不知道compliation:n的大小是通过构造函数传递的。