Boost::Array与Std::Vector使用与性能

大家都希望可以像操作STL容器一样的去操作数组，C++可没有提供这个东西，有时候你会选择使用vector来替代，不过这毕竟不是个好的办法，毕竟vector模拟动态数组比较稳妥，而用它去替代一个普通的数组，开销毕竟太大了。而恰好，boost::array就为你提供了这个功能。boost::array的定义如下（简化）：

template < class T, std::size_t N >    
class array
{    
public :        T elems[N];    // fixed-size array of elements of type T     
public :        // type definitions     
    typedef T              value_type;
    typedef T *              iterator;
    typedef const T *        const_iterator; 
    typedef T &              reference;    
    typedef const T &        const_reference;
    typedef std::size_t    size_type;     
    typedef std::ptrdiff_t difference_type;   
    // iterator support      
    iterator begin() { return elems; }      
    const_iterator begin() const { return elems; }  
    iterator end() { return elems + N; }      
    const_iterator end() const { return elems + N; }
    // operator[]      
    reference operator [](size_type i) ;        
    const_reference operator [](size_type i) const ;        // at() with range check      
    reference at(size_type i) ;       
    const_reference at(size_type i) const ;            // front() and back()      
    reference front() ;            
    const_reference front() const ;             
    reference back() ;              
    const_reference back() const ;               // size is constant       
    static size_type size() { return N; }   
    static bool empty() { return false ; }    
    static size_type max_size() { return N; } 
    enum { static_size = N };        // swap (note: linear complexity)      
    void swap (array < T,N >& y) ;   
}

　　显而易见，其实它只是将数组简单的包装，并附加了迭代器而已，你可以把它当成是普通的数组来使用，也可以进行STL的算法操作，是不是很方便？当然它也是有弊端的，当你想要创建一个未知个数的数组时，你就无能为力了：

  
  

   
   int
   
   [] arr 
   
   =
   
    {
   
   1
   
   ,
   
   2
   
   ,
   
   3
   
   };

   
   //
   
   boost::array<int,N> arr = {1,2,3} 
   
   //
   
   error!
  
  

　　当然，有这种需要的时候你还是要用普通的数组，不过在其他的时候呢？

　　那么，我们来比较一下他们的运行效率。

　　我们分别创建boost::array,std::vector,普通数组,并对他们进行赋值。

  
  

   
   #define
   
    _size       10000
   
   

   
   #define
   
    _recount    10000
   
   


   
   //
   
    计算时间用
   
   

   
   DWORD start, finish;  

   
   double
   
     duration;
  
  

首先是boost::array

boost::array < int ,_size > a_int;
start = timeGetTime();
int i = 0 ;
for (i = 0 ;i < _recount;i ++ )
{
    for ( int j = 0 ;j < _size;j ++ )
    {
        a_int[j] = j;
    }
}
finish = timeGetTime();
duration = ( double )(finish - start) / CLOCKS_PER_SEC;

 然后是std::vector

vector < int > v_int;
v_int.resize(_size);
start = timeGetTime();
for (i = 0 ;i < _recount;i ++ )
{
    for ( int j = 0 ;j < _size;j ++ )
    {
        v_int[j] = j;
    }
}
finish = timeGetTime();
duration = ( double )(finish - start) / CLOCKS_PER_SEC;

 最后是普通数组 

int _int[_size];
start = timeGetTime();
for (i = 0 ;i < _recount;i ++ )
{
    for ( int j = 0 ;j < _size;j ++ )
    {
        _int[j] = j;
    }
}
finish = timeGetTime();duration = ( double )(finish - start) / CLOCKS_PER_SEC;

 得出运行时间：

  
  

   
   Boost::array  : 
   
   3.296
   
   
std::vector   : 
   
   10.453
   
   
普通数组        : 
   
   0.296
   
   

  
  

Oh my god ! 相差这么多? 恩，的确相差了这么多！因为我们是使用的int类型作为操作数，那么当我们使用自定义的class的时候时间如下：

  
  

   
   boost::array  : 
   
   12.656
   
   
std::vector   : 
   
   18.656
   
   
普通数组        : 
   
   9.609
  
  

这个时候，我们可以看出，普通的数组比boost::array快了1/4，而比std::vector快了1/2。