int nArray[4] = {1,2,3,4};
const int Len = sizeof( nArray ) / sizeof( int );
int nCount = std::count( nArray, nArray + Len, 3 );
 

int nArray[4] = {1,2,3,4};
int nArray2[4] = nArray;        // 这种优雅的语法实在比 memcpy 等更具有观赏性
std::swap( nArray, nArray2 );   // 适应这种算法也更通用
 

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");
            }
        }

    };
 

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

array<int, 5> arr = {1,2,3,4,5};