如果你是STL的慣用者，且對效率持有莫大的興趣，你可能會對原生數組而不能優雅的與 STL 算法結合而感到不滿和懊惱，你充其量可以這樣使用：
int nArray[4] = {1,2,3,4};
const int Len = sizeof( nArray ) / sizeof( int );
int nCount = std::count( nArray, nArray + Len, 3 );
然而你不肯運用其他如 swap 等算法，數組是一個小型集合， 不能直接賦值。可能在模板中你更渴望有直接賦值的要求：
int nArray[4] = {1,2,3,4};
int nArray2[4] = nArray; // 這種優雅的語法實在比 memcpy 等更具有觀賞性
std::swap( nArray, nArray2 ); // 適應這種算法也更通用
幸而，boost提供了這樣一個物件： array, 說到底，array 只是原生數組的淺薄包裝而已，你甚至可以像原生數組那樣直接以大括號形式的賦值方式賦值：
array <int, 2> array = {{1,2}};
array <int, 2> array = {1,2}; // 顯然大部分編譯器已經支持一個大括號的初始化了
這種賦值方式的技術要求是：
1. 不允許有用戶定義的構造函數( 可以有析構 )
2. 不允許有 private 和 protected 的數據成員 ( 可以有 static 成員 )
3. 不允許有 父類
4. 無虛函數
從 C++ 對象模型角度來說，其結構在內存中是連續的一段，沒有額外的其他東西如虛表指針.
下面是其簡單定義：
template<class T, std::size_t N>
class array {
public:
T elems[N]; // 被包裝之原生數組
public:
// 類型定義
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 begin() { return elems; }
iterator end() { return elems+N; }
// 反向迭代器支持
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
reverse_iterator rbegin() { return reverse_iterator(end()); }
reverse_iterator rend() { return reverse_iterator(begin()); }
// 操作符[]
reference operator[](size_type i)
{
BOOST_ASSERT( i < N && "out of range" );
return elems[i];
}
// 帶有檢查的 at()
reference at(size_type i) { rangecheck(i); return elems[i]; }
const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
// front() 和 back()
reference front()
{
return elems[0];
}
reference back()
{
return elems[N-1];
}
// 大小為常量， 提供了 enum 來支持模板編程
static size_type size() { return N; }
static bool empty() { return false; }
static size_type max_size() { return N; }
enum { static_size = N };
// swap (線性復雜度)
void swap (array<T,N>& y) {
std::swap_ranges(begin(),end(),y.begin());
}
// direct access to data (read-only)
const T* data() const { return elems; }
T* data() { return elems; }
// use array as C array (direct read/write access to data)
T* c_array() { return elems; }
// 允許類型轉換的賦值
template <typename T2>
array<T,N>& operator= (const array<T2,N>& rhs) {
std::copy(rhs.begin(),rhs.end(), begin());
return *this;
}
// 數組填充某一值
void assign (const T& value)
{
std::fill_n(begin(),size(),value);
}
// 檢測區間
static void rangecheck (size_type i) {
if (i >= size()) {
throw std::out_of_range("array<>: index out of range");
}
}
};
當 N = 0 時， 像elem[0]這樣的語法是錯誤的，故以偏特化。內部去掉了 T elems[N]; 大部分接口只是為了統一，內部并未實作，頂多是拋出異常。
另外，一些有用的協助函數，主要是比較函數： ==, <, !=, >, <=, >=. 還有一個全局的swap,內部主要調用array內部的swap實現：
// swap()
template<class T, std::size_t N>
inline void swap (array<T,N>& x, array<T,N>& y) {
x.swap(y);
}
瑕疵：
不過，我們只有顯示的提供給數組一個大小，不能再像下面一樣使用編譯器來替我們工作了：
而只有這樣：
array<int, 5> arr = {1,2,3,4,5};
另外，像 char 這樣的特殊元素， 我們就不免小心（見下篇）。
不過，比起array之功，這點瑕疵也完全可以忽略。