C++ 是否有接受预填充&；的随机访问容器类型；预分配缓冲区？

我想自己写点东西，因为我没有找到我要找的东西，但我想我应该在潜入之前问问人群

• 是否存在允许传入预填充缓冲区的boost或stl随机访问容器类型

虚构的（？）容器类型的操作如下：

  const int blobSize = unpackBlobSize( msg );
  int *     blob     = unpackBlobData( msg );

  SpecialVector<int> mySpecialIntVector( blob, blobSize );

const int blobSize=解包blobSize（msg）；
int*blob=unpackBlobData（msg）；
SpecialVector mySpecialIntVector（blob，blobSize）；

基本上我是用一个C风格的原始指针与缓冲区接口，但是不需要复制步骤，而是使用C++风格的容器语义。我希望的是std:：vector加上预分配和预填充的缓冲区构造函数，再减去resize

Libeigen的Eigen:：Map具有这种功能，它允许以下内容：

  int array[9];
  for(int i = 0; i < 9; ++i) 
      array[i] = i;
  stl::cout << Eigen::Map<Eigen::Matrix3i>(array) << stl::endl;

int数组[9]；
对于（int i=0；i<9；++i）
数组[i]=i；
没有你想要的，这只是语言的一个缺点。如果您对让分配器静态地猜测一个良好的预期最大元素计数感到满意，那么您可以在分配器中嵌入一个普通的C数组，并尽可能长时间地遵从它；这通常称为自动缓冲区


旧答案：

所有标准库容器都允许您指定分配器。您可以创建缓冲区分配器。
根据Dennis Zickenfose的评论，我查找了Boost.range似乎提供了完美的解决方案：

  #include <boost/range.hpp>
  #include <boost/foreach.hpp>
  #include <iostream>

  int main()
  {
    const int blobSize = 100;
    int blob[blobSize];

    for( int i = 0; i < blobSize; ++i )
      blob[i] = i;

    boost::iterator_range<int*> blobPsudoContainer( blob, blob + blobSize );

    BOOST_FOREACH( int & i, blobPsudoContainer )
      i = i + 1;

    std::cout << "Size is:" << blobPsudoContainer.size() << "\n";
    std::cout << "value at 0 is:" << blobPsudoContainer[0] << "\n";
    return 0;
  }

#包括
#包括
#包括
int main（）
{
常量int blobSize=100；
int blob[blobSize]；
对于（int i=0；istd：：cout我想我应该为后代发布最终使用的自定义解决方案，以防有人好奇或有任何评论。请原谅格式过于紧凑；这是为了摆脱水平卷轴

如果你使用这个，一定要在评论部分告诉我。我很想知道它是否对其他人有用

我们需要以下标题：

 #include <boost/range/iterator_range.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/shared_array.hpp>
 #include <vector>

#包括
#包括
#包括
#包括

用于钩住现有参照计数对象的辅助对象

 template<typename RefCountedTypeT>
 struct RefCountLinkFunctor
 {
   public:
     RefCountLinkFunctor( const RefCountedTypeT & ptr ) 
       : m_ptr(ptr) 
     { 
       &RefCountedTypeT::use_count; // try to check if refcounted
      } 

      template<typename T> void operator()(T*) {}

   protected:
     RefCountedTypeT m_ptr;
 };

模板
结构RefCountLinkFunctor
{
公众：
RefCountLinkFunctor（常量RefCountedTypeT&ptr）
：m_ptr（ptr）
{ 
&RefCountedTypeT:：use_count；//尝试检查refcounted
} 
模板无效运算符（）（T*）{}
受保护的：
参考计数类型m_ptr；
};

然后：

 template< typename DataT >
 class DataRange : public boost::iterator_range< DataT * >
 {
 public:
   typedef boost::iterator_range< DataT * >    ParentType;
   typedef DataRange< DataT >                  OwnType;
   typedef DataT                               DataType;
   typedef boost::iterator_range< DataType * > Range;
   typedef boost::shared_ptr< OwnType >        Ptr;
   typedef std::vector<DataType>               DataVector;
   typedef boost::shared_ptr<DataVector>       DataVectorPtr;

   static Ptr allocateShared( std::size_t size )
   {
     typedef boost::shared_array<DataType>         DataSharedArray;
     typedef RefCountLinkFunctor<DataSharedArray>  Deleter;

     DataSharedArray   dataArray( new DataType[size] );
     Deleter           deleter( dataArray );

     DataT * begin = dataArray.get();
     DataT * end   = begin + size;

     return Ptr( new OwnType(begin, end), deleter);
   }

   template< typename RefCountedT >
   static Ptr 
   makeShared( DataType * begin, DataType * end, const RefCountedT & refObj )
   {
     RefCountLinkFunctor< RefCountedT >  deleter( refObj );
     return Ptr( new OwnType(begin, end), deleter );
   }

   template< typename RefCountedT, typename InDataT >
   static Ptr 
   makeShared( DataVector & data, const RefCountedT & refObj )
   {
     RefCountLinkFunctor< RefCountedT >  deleter( refObj );

     DataType * begin = &data.front();
     DataType * end   = begin + data.size();

     return makeShared( begin, end, deleter );
   }

   static Ptr makeShared( const DataVectorPtr & data )
   {
     typedef boost::shared_ptr< std::vector<DataType> > InputVectorPtr;

     RefCountLinkFunctor< InputVectorPtr >  deleter( data );

     DataType * begin = &data->front();
     DataType * end   = begin + data->size();

     return makeShared( begin, end, deleter );
   }

 protected:
     DataRange( DataType * begin, DataType * end ) : ParentType( begin, end ){}

};

模板
类DataRange:publicboost:：迭代器_range
{
公众：
typedef boost:：iterator_rangeParentType；
typedef DataRangeOwnType；
typedef数据类型；
typedef boost:：迭代器范围范围；
typedef boost:：shared_ptrptr；
typedef std：：向量数据向量；
typedef boost:：shared_ptr DataVectorPtr；
静态Ptr分配共享（标准：：大小\u t大小）
{
typedef boost:：共享_阵列数据共享阵列；
typedef RefCountLinkFunctor Deleter；
数据共享阵列数据阵列（新数据类型[大小]）；
Deleter Deleter（数据数组）；
DataT*begin=dataArray.get（）；
数据*结束=开始+大小；
返回Ptr（新的所有者类型（开始、结束）、删除者）；
}
模板
静态Ptr
makeShared（数据类型*开始，数据类型*结束，常数RefCountedT&refbj）
{
RefCountLinkFunctordeleter（refObj）；
返回Ptr（新的所有者类型（开始、结束）、删除者）；
}
模板
静态Ptr
makeShared（数据向量和数据、常量RefCountedT和refObj）
{
RefCountLinkFunctordeleter（refObj）；
数据类型*begin=&data.front（）；
数据类型*end=begin+data.size（）；
返回makeShared（开始、结束、删除）；
}
静态Ptr makeShared（常量数据向量Ptr和数据）
{
typedef boost:：shared_ptrInputVectorPtr；
RefCountLinkFunctordeleter（数据）；
数据类型*begin=&data->front（）；
数据类型*end=begin+data->size（）；
返回makeShared（开始、结束、删除）；
}
受保护的：
数据范围（数据类型*开始，数据类型*结束）：父类型（开始，结束）{}
};
非常有趣的想法。不过，我仍然会有调整大小的问题。@Catskul在调整大小时，它将使用您的自定义分配器。看起来他希望提供的缓冲区已经包含初始化值；标准库容器将假定分配器返回未初始化的内存，并覆盖现有数据。我要写它，但现在我们应该澄清：@Cat:你想传入缓冲区，还是假设某种预期的静态缓冲区。你为什么要动态分配缓冲区？@Catskul:那么也许我遗漏了什么，但为什么不开始使用你的缓冲区呢？将它粘贴在
std:：vector
中，然后不使用
std:：vector
features gain？我对该库不太熟悉，但我相信Boost.Range可能有一些您可以使用的功能。据我所知，它提供了一些薄包装，使成对的迭代器看起来像containers@Dennis这似乎是一个真正的解决方案。检查一下。@Dennis，你想做这个吗或者我可以回答吗？请放心，我实际上还没有深入研究它来给出一个有效的例子。这是我的观点，我没有看到一个例子。在
vector
的API（如果不是自动调整大小）中，你缺少什么？“安全（er）C++/STL方式”只是文字，对不起。你可以像y一样快乐地跑出vector的边界