首先，命名空間為boost,array較小，只有一個單獨的array.hpp文件。
array的目的主要是在STL的動態數組與傳統功能有限的普通數組之間做一個折衷。為高效的靜態數組增添一些其他的功能。
template<class T,std::size_t N>
class array{
public:
T elems[N];
內部的底層實現即用的傳統的數組。數組的大小由初始化時指定，但類型則由模板指定。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;
類似于STL的特性萃取機制。
// iterator support
iterator begin() { return elems; }
const_iterator begin() const { return elems; }
const_iterator cbegin() const { return elems; }
iterator end() { return elems+N; }
const_iterator end() const { return elems+N; }
const_iterator cend() const { return elems+N; }
提供類似于STL容器的接口。但這里的實現很簡單，因為是靜態數組。注意end()返回的指針是指向
數組之后的一位，這點同STL的接口一致。
reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const {
return const_reverse_iterator(end());
}
const_reverse_iterator crbegin() const {
return const_reverse_iterator(end());
}
reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const {
return const_reverse_iterator(begin());
}
const_reverse_iterator crend() const {
return const_reverse_iterator(begin());
}
反向迭代器，也是類似于STL中的功能，在具體實現上就是用的STL的函數將普通迭代器轉化。
// operator[]
reference operator[](size_type i)
{
BOOST_ASSERT( i < N && "out of range" );
return elems[i];
}
const_reference operator[](size_type i) const
{
BOOST_ASSERT( i < N && "out of range" );
return elems[i];
}
重載【】操作符，兩個版本:const和非const.BOOST_ASSERT是BOOST庫提供的靜態斷言功能，可以在編譯期
發現錯誤。比如說在程序編譯時就可以發現數組越界，報錯。C的最新標準里也加入了靜態斷言的內容。
// at() with range check
reference at(size_type i) { rangecheck(i); return elems[i]; }
const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
at()訪問函數。亦分const 與非const 版本，二者的不同體現雜返回值上。注意前面的定義，reference
為T&,const_reference為const T&.實現上首先也是邊界檢查，我們來看一下rangecheck函數
// check range (may be private because it is static)
static void rangecheck (size_type i) {
if (i >= size()) {
std::out_of_range e("array<>: index out of range");
boost::throw_exception(e);
}
}
若游標大于界限，則拋出異常，std::out_of_range,
class out_of_range : public logic_error {
public:
explicit out_of_range (const string& what_arg);
};
class logic_error : public exception {
public:
explicit logic_error (const string& what_arg);
};
這里的異常的主要是為了向編譯者提供一個清晰的錯誤說明。 // front() and back()
reference front()
{
return elems[0];
}
const_reference front() const
{
return elems[0];
}
reference back()
{
return elems[N-1];
}
const_reference back() const
{
return elems[N-1];
}
front和back函數，實現起來是很簡單的，也很高效的。
// 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 };
類似于STL容器的返回大小的接口。因為是靜態數組，大小不變，所以主要的目的只是為了與STL的接口兼容，實現起來并沒有多大意義。像empty()函數，對vector來說很有用，但對一個長度固定的
函數則是沒有什么意義的（總是返回false),所以在設計上主要的考慮是在別的地方。
// swap (note: linear complexity)
void swap (array<T,N>& y) {
for (size_type i = 0; i < N; ++i)
boost::swap(elems[i],y.elems[i]);
}
boost:swap是utility中的一個組件。其實現如下：
namespace boost
{
template<class T1, class T2>
void swap(T1& left, T2& right)
{
::boost_swap_impl::swap_impl(left, right);
}
}
而swap_impl的實現在boost命名空間之外。
namespace boost_swap_impl
{
template<class T>
void swap_impl(T& left, T& right)
{
using namespace std;//use std::swap if argument dependent lookup fails
swap(left,right);
}
template<class T, std::size_t N>
void swap_impl(T (& left)[N], T (& right)[N])
{
for (std::size_t i = 0; i < N; ++i)
{
::boost_swap_impl::swap_impl(left[i], right[i]);
}
}
}
boost:swap有兩個template的好處是可以很好地與std:swap分別開來。當同時出現時，std:swap是優先的。
// direct access to data (read-only)
const T* data() const { return elems; }
T* data() { return elems; }
直接返回數組首地址。
T* c_array() { return elems; }
直接返回數組首地址用于進行C類型的數組操作。
template <typename T2>
array<T,N>& operator= (const array<T2,N>& rhs) {
std::copy(rhs.begin(),rhs.end(), begin());
return *this;
}
賦值操作符。用的是STL中的通用算法。
void assign (const T& value) { fill ( value ); } // A synonym for fill
void fill (const T& value)
{
std::fill_n(begin(),size(),value);
}