Question

我需要为3个std :: vector实例替换3个堆分配只有一个连续的堆分配，然后在这3个向量之间共享它。这些矢量大小不会改变，所以我不需要担心在推送或插入元素的情况下分配新的连续存储。我的实验结果表明，当我用一个大小为* 3 * n *的向量替换这些大小为 n 的3个向量时，我可以获得不同大小的2倍速度。

但是，我并不确切知道如何在不进行额外堆分配的情况下完成从较大的向量中制作较小向量的工作。

std::array<std::vector<double>, 3>
chunck_vector(size_t size)
{
  std::vector<double> * underlying_vec = new std::vector<double>(3*size, 1.0);

  // how to avoid extra heap allocations in constructor of small vectors
  std::vector<double> vec0(underlying_vec->begin()         , underlying_vec->begin() + size);
  std::vector<double> vec1(underlying_vec->begin() + size  , underlying_vec->begin() + 2*size);
  std::vector<double> vec2(underlying_vec->begin() + 2*size, underlying_vec->end());

  return {vec0, vec1, vec2};
}

int main(int argc, char const *argv[])
{
  int size = 1000;

  auto&& chunked_vecs = chunck_vector(size);

  // passing each chunk to different functions
  // each chunk should be responsible for managing its resources
  foo0(std::get<0>(chunked_vecs));
  foo1(std::get<1>(chunked_vecs));
  foo2(std::get<2>(chunked_vecs));

  return 0;
}

我尝试编写自己的vector类，它的构造函数接受两个迭代器，指定 underlying_vec 存储部分的开始和结尾属于这个向量，但是它不是一个干净的解决方案。当底层向量不再可访问并解决内存泄漏问题时，它就可以释放资源。

显然使用在这三个向量之间共享的自定义分配器并分配一个连续的内存并将其分配给相应的向量似乎是一个更好的解决方案，但是因为我从来没有写过任何提示或建议来帮助我启动编码将不胜感激。

Answer 1

gsl::span就是为此而设计的。

您可以找到实施HERE。建议将其包含在C++标准库中。

你可以像这样使用它：

void double_data(gsl::span<int> sp)
{
    for(auto& i: sp)
        i *= 2;
}

void tripple_data(gsl::span<int> sp)
{
    for(auto& i: sp)
        i *= 3;
}

int main()
{
    std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    auto sp = gsl::make_span(v); // the whole vector

    auto sp1 = sp.subspan(0, 5); // first 5 elements
    auto sp2 = sp.subspan(5, 5); // last five elements

    double_data(sp1); // process it like you would a container

    tripple_data(sp2);

    for(auto i: v)
        std::cout << i << ' ';
    std::cout << '\n';
}

<强>输出：

2 4 6 8 10 18 21 24 27 30

Answer 2

您可以使用std::shared_ptr，其主要目的是管理共享资源。首先，创建缓冲区：

std::shared_ptr<double> underlying(new double[3 * size], std::default_delete<double[]>());

在这里，您必须使用default_delete作为显式删除器，因此使用正确的operator delete[]进行重新分配。顺便说一句，我听说在C ++ 17中你不再需要使用显式删除器，如果你使用shared_ptr<double[]>。

然后使用别名构造函数：

定义较小的容器

std::shared_ptr<double> vec0(underlying, underlying.get());
std::shared_ptr<double> vec1(underlying, underlying.get() + size);
std::shared_ptr<double> vec2(underlying, underlying.get() + 2 * size);

在这里，您可以使用＆＃34;向量＆＃34;直到它们的最后一个超出范围，并且当发生这种情况时，缓冲区被释放。但是，这些不是载体 - 例如他们不会存储他们的大小，只有指向第一个元素的指针。

在没有额外堆分配的情况下将较大的向量分组到较小的向量

2 个答案: