1

我需要用一个连续的堆分配替换 3 个 std::vector 实例的 3 个堆分配，然后在这 3 个向量之间共享它。这些向量大小不会改变，所以我不需要担心在向它们推送或插入元素的情况下分配新的连续存储。我的实验结果表明，当我将这 3 个大小为n的向量替换为一个大小为 *3*n* 的向量时，对于不同的大小，我的速度提高了 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;
}

我尝试编写自己的向量类，它的构造函数接受两个迭代器，指定底层_vec存储部分的开始和结束属于该向量，但是当涉及到释放资源的工作时，这听起来不是一个干净的解决方案基础向量不再可访问并解决内存泄漏问题。

显然使用在这三个向量之间共享的自定义分配器并分配一次连续内存并将其分配给相应的向量似乎是一个更好的解决方案，但是由于我从未编写过一个，任何帮助我开始编码的提示或建议将是赞赏。

4

2 回答 2

2

这就是gsl::span的设计目的。

你可以在这里找到一个实现。建议将其包含在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
于 2018-03-14T20:34:41.317 回答
1

您可以使用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);

在这里，您可以使用您的“向量”，直到它们中的最后一个超出范围，当这种情况发生时，缓冲区被释放。然而，这些不是向量——例如，它们不存储它们的大小，只存储指向第一个元素的指针。

于 2018-03-15T20:40:52.157 回答