将动态数组包装到 STL/Boost 容器中？

Question

我需要将动态分配的数组（例如从 a = new double[100] ）包装到 std::vector （最好）而不复制数组。 此限制是由于我想要包装的数组是从文件映射而来的，因此仅执行向量（a，a+size）就会使内存使用量增加一倍。

有什么技巧可以做到这一点吗？

Answer 1

最好的解决方案之一是类似于 STLSoft 的 array_proxy 模板。不幸的是，doxygen 从源代码生成的文档页面并不能帮助理解模板。源代码实际上可能更好一点：

• http://www. stlsoft.org/doc-1.9/array__proxy_8hpp-source.html

array_proxy<> 模板在 Matthew Wilson 的书《不完美的 C++》。我使用的版本是 STLSoft 网站上内容的精简版本，因此我不必引入整个库。我的版本不是那么可移植，但这使得它比 STLSoft 上的版本简单得多（它跳过了很多可移植性的障碍）。

如果您像这样设置变量：

int myArray[100];

array_proxy<int> myArrayProx( myArray);

变量 myArrayProx 有许多 STL 接口 - begin()、end()、size()、迭代器等。

因此，在很多方面，array_proxy 对象的行为就像一个向量（尽管 push_back() 不是t 在那里，因为 array_proxy<> 无法增长 - 它不管理数组的内存，它只是将其包装在更接近向量的东西中）。

array_proxy<> 的一件非常好的事情是，如果将它们用作函数参数类型，则函数可以确定传入数组的大小，而本机数组则不然。并且包装数组的大小不是模板类型的一部分，因此使用起来非常灵活。

Answer 2

boost::iterator_range 提供了类似容器的接口：

// Memory map an array of doubles:
size_t number_of_doubles_to_map = 100;
double* from_mmap = mmap_n_doubles(number_of_doubles_to_map);

// Wrap that in an iterator_range
typedef boost::iterator_range<double*> MappedDoubles;
MappedDoubles mapped(from_mmap, from_mmap + number_of_doubles_to_map);

// Use the range
MappedDoubles::iterator b = mapped.begin();
MappedDoubles::iterator e = mapped.end();
mapped[0] = 1.1;
double first = mapped(0);

if (mapped.empty()){
    std::cout << "empty";
}
else{
    std::cout << "We have " << mapped.size() << "elements. Here they are:\n"
       << mapped;
}

Answer 3

我曾经决心完成同样的事情。经过几天的思考和尝试，我认为这不值得。我最终创建了自己的自定义向量，其行为类似于 std::vector，但只具有我实际需要的功能，例如边界检查、迭代器等。

如果您仍然希望使用 std::vector，这是我当时能想到的唯一方法是创建一个自定义分配器。我从来没有写过，但鉴于这是控制 STL 内存管理的唯一方法，也许可以在那里做一些事情。

Answer 4

不，使用 std::vector 是不可能的。

但如果可能的话，您可以创建具有此大小的向量，并可能将文件映射到该向量。

std::vector<double> v(100);
mmapfile_double(&v[0], 100);

Answer 5

指向映射区域元素的指针向量怎么样（由于 sizeof(double*) < sizeof(double) 减少了内存消耗）？这对你来说可以吗？

有一些缺点（主要是您需要特殊的谓词进行排序），但也有一些好处，例如，您可以删除元素而不更改实际映射内容（或者拥有偶数个具有不同元素顺序的此类数组，而不需要更改实际映射内容）值）。

在映射文件上使用 std::vector 的所有解决方案都有一个共同的问题：将矢量内容“钉”到映射区域。这是无法跟踪的，您只能自己注意不要使用可能导致矢量内容重新分配的东西。所以无论如何都要小心。

Answer 6

您可以使用 array_proxy<>，或者查看 Boost.Array。它为您提供 size()、front()、back()、at()、operator[] 等。就个人而言，我更喜欢 Boost.Array，因为无论如何 Boost 更流行。

Answer 7

好吧，向量模板允许提供您自己的内存分配器。我自己从来没有这样做过，但我想让它指向你的数组并不难，也许通过放置新运算符......只是一个猜测，如果我尝试并成功，我会写更多。

Answer 8

这是您问题的解决方案。在我想出一个可行的解决方案之前，我断断续续地尝试了很长一段时间。需要注意的是，使用后必须将指针清零，以避免双重释放内存。

#include <vector>
#include <iostream>

template <class T>
void wrapArrayInVector( T *sourceArray, size_t arraySize, std::vector<T, std::allocator<T> > &targetVector ) {
  typename std::_Vector_base<T, std::allocator<T> >::_Vector_impl *vectorPtr =
    (typename std::_Vector_base<T, std::allocator<T> >::_Vector_impl *)((void *) &targetVector);
  vectorPtr->_M_start = sourceArray;
  vectorPtr->_M_finish = vectorPtr->_M_end_of_storage = vectorPtr->_M_start + arraySize;
}

template <class T>
void releaseVectorWrapper( std::vector<T, std::allocator<T> > &targetVector ) {
  typename std::_Vector_base<T, std::allocator<T> >::_Vector_impl *vectorPtr =
        (typename std::_Vector_base<T, std::allocator<T> >::_Vector_impl *)((void *) &targetVector);
  vectorPtr->_M_start = vectorPtr->_M_finish = vectorPtr->_M_end_of_storage = NULL;
}

int main() {

  int tests[6] = { 1, 2, 3, 6, 5, 4 };
  std::vector<int> targetVector;
  wrapArrayInVector( tests, 6, targetVector);

  std::cout << std::hex << &tests[0] << ": " << std::dec
            << tests[1] << " " << tests[3] << " " << tests[5] << std::endl;

  std::cout << std::hex << &targetVector[0] << ": " << std::dec
            << targetVector[1] << " " << targetVector[3] << " " << targetVector[5] << std::endl;

  releaseVectorWrapper( targetVector );
}

或者，您可以创建一个继承自 Vector 的类，并在销毁时清空指针：

template <class T>
class vectorWrapper : public std::vector<T>
{   
public:
  vectorWrapper() {
    this->_M_impl _M_start = this->_M_impl _M_finish = this->_M_impl _M_end_of_storage = NULL;
  }   

  vectorWrapper(T* sourceArray, int arraySize)
  {   
    this->_M_impl _M_start = sourceArray;
    this->_M_impl _M_finish = this->_M_impl _M_end_of_storage = sourceArray + arraySize;
  }   

  ~vectorWrapper() {
    this->_M_impl _M_start = this->_M_impl _M_finish = this->_M_impl _M_end_of_storage = NULL;
  }   

  void wrapArray(T* sourceArray, int arraySize)
  {   
    this->_M_impl _M_start = sourceArray;
    this->_M_impl _M_finish = this->_M_impl _M_end_of_storage = sourceArray + arraySize;
  }   
};