销毁 std::vector 而不释放内存

Question

假设我有一个函数可以将数据输入标准向量：

void getData(std::vector<int> &toBeFilled) {
  // Push data into "toBeFilled"
}

现在我想将此数据发送到另一个函数，完成后应该释放数据：

void useData(int* data)
{
  // Do something with the data...
  delete[] data;
}

这两个函数（getData 和 useData）都是固定的，不能更改。这在复制数据一次时效果很好：

{
  std::vector<int> data;
  getData(data);
  int *heapData = new int[data.size()];
  memcpy(heapData, data.data(), data.size()*sizeof(int));
  useData(heapData);
  data.clear();
}

但是，这个 memcpy 操作代价高昂，并不是真正需要的，因为数据已经在堆上。是否可以直接提取和使用标准向量分配的数据？类似（伪代码）：

{
  std::vector<int> data;
  getData(data);
  useData(data.data());
  data.clearNoDelete();
}

编辑：

这个例子可能没有太多意义，因为可以在函数调用 useData 之后释放向量。但是，在真实的代码中，useData并不是一个函数，而是一个接收数据的类，而且这个类的寿命比vector长……

Answer 1

没有。

您使用的 API 有一个合同，规定它拥有您提供给它的数据的所有权，并且这些数据是通过指针提供的。这基本上排除了使用标准向量。

Vector 将始终确保释放它分配的内存并安全地销毁它包含的元素。这是其保证合同的一部分，您不能将其关闭。

如果您希望获得数据的所有权，您必须制作数据副本...或者将每个元素移出到您自己的容器中。或者首先从您自己的 new[] 开始（呃），尽管您至少可以将所有这些包装在某个模仿 std::vector 的类中并变成非拥有者。

Answer 2

这是一个可怕的 hack，它应该可以让你做你需要做的事情，但它依赖于 Undefined Behavior 做最简单的事情。这个想法是创建您自己的分配器，它与 std::allocator 布局兼容，并对向量进行类型双关：

template <class T>
struct CheatingAllocator : std::allocator<T>
{
  using typename std::allocator<T>::pointer;
  using typename std::allocator<T>::size_type;

  void deallocate(pointer p, size_type n) { /* no-op */ }

  // Do not add ANY data members!!
};


{
  std::vector<int, CheatingAllocator<int>> data;
  getData(reinterpret_cast<std::vector<int>&>(data)); // type pun, `getData()` will use std::allocator internally
  useData(data.data());
  // data actually uses your own allocator, so it will not deallocate anything
}

请注意，这与黑客行为一样骇人听闻且不安全。它依赖于内存布局不变，它依赖于std::allocator 在其allocate 函数中使用new[]。我自己不会在生产代码中使用它，但我相信这是一个（绝望的）解决方案。

---

@TonyD 在 cmets 中正确指出 std::allocator 很可能不在内部使用 new[]。因此，上述操作很可能在useData() 内的delete[] 上失败。同样的@TonyD 也提出了一个很好的观点，即使用reserve() 来（希望）防止getData() 内部的重新分配。所以更新后的代码如下所示：

template <class T>
struct CheatingAllocator : std::allocator<T>
{
  using typename std::allocator<T>::pointer;
  using typename std::allocator<T>::size_type;

  pointer allocate(size_type n) { return new T[n]; }

  void deallocate(pointer p, size_type n) { /* no-op */ }

  // Do not add ANY data members!!
};


{
  std::vector<int, CheatingAllocator<int>> data;
  data.reserve(value_such_that_getData_will_not_need_to_reallocate);
  getData(reinterpret_cast<std::vector<int>&>(data)); // type pun, `getData()` will use std::allocator internally
  useData(data.data());
  // data actually uses your own allocator, so it will not deallocate anything
}